From 945bbbc96774eb95df9849ecd313e92a28a291a8 Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Wed, 7 Oct 2026 10:16:07 -0400
Subject: [PATCH 001/245] ci: reuse Python SDK upgrade PRs unless queued
 (#1021)

* ci: reuse Python SDK upgrade PRs unless queued

* ci: protect reused upgrade PRs from stale and queued writes
---
 .github/workflows/posthog-upgrade.yml         | 139 ++++++-
 posthog/test/test_posthog_upgrade_workflow.py | 388 ++++++++++++++++++
 2 files changed, 515 insertions(+), 12 deletions(-)
 create mode 100644 posthog/test/test_posthog_upgrade_workflow.py

diff --git a/.github/workflows/posthog-upgrade.yml b/.github/workflows/posthog-upgrade.yml
index 576f83920..19a04aa24 100644
--- a/.github/workflows/posthog-upgrade.yml
+++ b/.github/workflows/posthog-upgrade.yml
@@ -17,6 +17,10 @@ on:
 permissions:
   contents: read
 
+concurrency:
+  group: posthog-upgrade-${{ github.event.inputs.package_name }}
+  cancel-in-progress: false
+
 jobs:
   posthog-upgrade:
     name: Upgrade PostHog package
@@ -81,16 +85,117 @@ jobs:
               fi
           done
 
-      - name: Generate branch name
-        id: generate-branch-name
+      - name: Generate pull request details
+        id: generate-pr-details
         shell: bash
         env:
+          GH_TOKEN: ${{ steps.upgrader.outputs.token }}
           PACKAGE_NAME: ${{ github.event.inputs.package_name }}
           PACKAGE_VERSION: ${{ github.event.inputs.package_version }}
         run: |
-          echo "branch_name=${PACKAGE_NAME}-${PACKAGE_VERSION}" >> "$GITHUB_OUTPUT"
+          TITLE_PREFIX="chore(deps): update ${PACKAGE_NAME} to "
+
+          skip_update() {
+              echo "::notice::$1"
+              echo "skip=true" >> "$GITHUB_OUTPUT"
+              exit 0
+          }
+
+          # Serialize writers and reject stale reruns using Python package ordering.
+          check_version() {
+              local current_title="$1" current_version older
+              if [[ "$current_title" != "$TITLE_PREFIX"* ]]; then
+                  echo "::error::Cannot determine the destination PR's package version." >&2
+                  exit 1
+              fi
+              current_version="${current_title#"$TITLE_PREFIX"}"
+              older=$(uv run --no-project --with packaging==25.0 python - "$PACKAGE_VERSION" "$current_version" <<'PY'
+          import sys
+          from packaging.version import Version
+
+          print("true" if Version(sys.argv[1]) < Version(sys.argv[2]) else "false")
+          PY
+              ) || {
+                  echo "::error::Cannot compare package versions; leaving remote branches unchanged." >&2
+                  exit 1
+              }
+              if [ "$older" = "true" ]; then
+                  skip_update "Version $PACKAGE_VERSION is older than PR version $current_version; leaving it unchanged."
+              fi
+          }
+
+          queue_status() {
+              local pr="$1" status
+              if status=$(gh api "repos/PostHog/posthog/issues/${pr}/comments?per_page=100" \
+                  --paginate --slurp \
+                  --jq '[.[][] | select(.user.login == "trunk-io[bot]") | .body] | last // ""'); then
+                  printf '%s' "$status" \
+                      | grep -oE "Running tests on this pull request|waiting to start tests" | head -n 1 || true
+              else
+                  echo "::warning::Could not read the queue status of PR #${pr}; treating it as queued." >&2
+                  echo "unknown"
+              fi
+          }
+
+          EXISTING=$(gh pr list \
+              --repo PostHog/posthog \
+              --state open \
+              --search "\"${TITLE_PREFIX}\" in:title sort:created-desc" \
+              --limit 100 \
+              --json title,number,headRefName,headRepositoryOwner \
+              --jq ".[] | select(.title | startswith(\"${TITLE_PREFIX}\")) | select(.headRepositoryOwner.login == \"PostHog\") | [.number, .headRefName, .title] | @tsv" | head -n 1)
+          IFS=$'\t' read -r EXISTING_PR EXISTING_BRANCH EXISTING_TITLE <<< "$EXISTING"
+
+          # Updating a queued PR's branch restarts the merge queue's checks.
+          # Leave queued PRs alone, including when their status cannot be read.
+          QUEUED=""
+          if [ -n "$EXISTING_PR" ]; then
+              check_version "$EXISTING_TITLE"
+              QUEUED=$(queue_status "$EXISTING_PR")
+          fi
+
+          if [ -n "$EXISTING_BRANCH" ] && [ -z "$QUEUED" ]; then
+              BRANCH_NAME="$EXISTING_BRANCH"
+          elif [ -n "$QUEUED" ]; then
+              echo "::notice::PR #${EXISTING_PR} is in the merge queue; checking a separate branch instead."
+              BRANCH_NAME="${PACKAGE_NAME}-upgrade-${PACKAGE_VERSION}"
+              # A rerun can collide with an already queued version-specific PR.
+              if ! DESTINATIONS=$(gh pr list \
+                  --repo PostHog/posthog \
+                  --state open \
+                  --head "$BRANCH_NAME" \
+                  --limit 100 \
+                  --json title,number,headRefName,isCrossRepository \
+                  --jq '.[] | select(.isCrossRepository == false) | [.number, .headRefName, .title] | @tsv'); then
+                  skip_update "Could not check the fallback branch for an existing PR; leaving it unchanged."
+              fi
+              while IFS=$'\t' read -r DESTINATION_PR DESTINATION_BRANCH DESTINATION_TITLE; do
+                  [ -n "$DESTINATION_PR" ] || continue
+                  [ "$DESTINATION_BRANCH" = "$BRANCH_NAME" ] || continue
+                  check_version "$DESTINATION_TITLE"
+                  if [ -n "$(queue_status "$DESTINATION_PR")" ]; then
+                      skip_update "Fallback PR #${DESTINATION_PR} is queued or its status is unknown; leaving it unchanged."
+                  fi
+              done <<< "$DESTINATIONS"
+          else
+              BRANCH_NAME="${PACKAGE_NAME}-upgrade"
+          fi
+
+          echo "skip=false" >> "$GITHUB_OUTPUT"
+          echo "branch_name=$BRANCH_NAME" >> "$GITHUB_OUTPUT"
+          echo "title=${TITLE_PREFIX}${PACKAGE_VERSION}" >> "$GITHUB_OUTPUT"
+          {
+              echo 'body<<EOF'
+              echo '## Changes'
+              echo
+              echo "PostHog Python SDK version $PACKAGE_VERSION has been released. This updates the \`posthoganalytics\` and \`posthog\` dependency declarations to the same SDK version."
+              echo
+              echo '[GitHub releases](https://github.com/PostHog/posthog-python/releases) • [`posthoganalytics` on PyPI](https://pypi.org/project/posthoganalytics/#history) • [`posthog` on PyPI](https://pypi.org/project/posthog/#history)'
+              echo 'EOF'
+          } >> "$GITHUB_OUTPUT"
 
       - name: Create main repo pull request
+        if: steps.generate-pr-details.outputs.skip == 'false'
         id: main-repo-pr
         uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
         env:
@@ -99,18 +204,14 @@ jobs:
           token: ${{ steps.upgrader.outputs.token }}
           # PostHog/posthog requires signed commits, so commit through the GitHub API.
           sign-commits: true
-          commit-message: "chore(deps): update ${{ github.event.inputs.package_name }} to ${{ github.event.inputs.package_version }}"
-          branch: ${{ steps.generate-branch-name.outputs.branch_name }}
+          commit-message: ${{ steps.generate-pr-details.outputs.title }}
+          branch: ${{ steps.generate-pr-details.outputs.branch_name }}
           delete-branch: true
-          title: "chore(deps): update ${{ github.event.inputs.package_name }} to ${{ github.event.inputs.package_version }}"
-          body: |
-            ## Changes
-
-            PostHog Python SDK version ${{ github.event.inputs.package_version }} has been released. This updates the `posthoganalytics` and `posthog` dependency declarations to the same SDK version.
-
-            [GitHub releases](https://github.com/PostHog/posthog-python/releases) • [`posthoganalytics` on PyPI](https://pypi.org/project/posthoganalytics/#history) • [`posthog` on PyPI](https://pypi.org/project/posthog/#history)
+          title: ${{ steps.generate-pr-details.outputs.title }}
+          body: ${{ steps.generate-pr-details.outputs.body }}
 
       - name: Output pull request result
+        if: steps.generate-pr-details.outputs.skip == 'false'
         shell: bash
         env:
           PACKAGE_NAME: ${{ github.event.inputs.package_name }}
@@ -119,7 +220,21 @@ jobs:
         run: |
           echo "PostHog pull request for $PACKAGE_NAME version $PACKAGE_VERSION ready: $PR_URL"
 
+      - name: Update pull request metadata
+        if: steps.generate-pr-details.outputs.skip == 'false'
+        env:
+          GH_TOKEN: ${{ steps.upgrader.outputs.token }}
+          PR_BODY: ${{ steps.generate-pr-details.outputs.body }}
+          PR_NUMBER: ${{ steps.main-repo-pr.outputs.pull-request-number }}
+          PR_TITLE: ${{ steps.generate-pr-details.outputs.title }}
+        run: |
+          gh pr edit "$PR_NUMBER" \
+              --repo PostHog/posthog \
+              --title "$PR_TITLE" \
+              --body "$PR_BODY"
+
       - name: Assign reviewers
+        if: steps.generate-pr-details.outputs.skip == 'false'
         env:
           GH_TOKEN: ${{ steps.upgrader.outputs.token }}
           PR_NUMBER: ${{ steps.main-repo-pr.outputs.pull-request-number }}
diff --git a/posthog/test/test_posthog_upgrade_workflow.py b/posthog/test/test_posthog_upgrade_workflow.py
new file mode 100644
index 000000000..a8b91ecaa
--- /dev/null
+++ b/posthog/test/test_posthog_upgrade_workflow.py
@@ -0,0 +1,388 @@
+"""Exercise the inline downstream-upgrade selector without GitHub writes."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+
+WORKFLOW = Path(__file__).resolve().parents[2] / ".github/workflows/posthog-upgrade.yml"
+TITLE_PREFIX = "chore(deps): update posthoganalytics to "
+FALLBACK = "posthoganalytics-upgrade-7.64.1"
+RUNNING = "Running tests on this pull request"
+WAITING = "waiting to start tests"
+
+
+def step_source(name):
+    return (
+        WORKFLOW.read_text()
+        .split(f"      - name: {name}\n", 1)[1]
+        .split("      - name:", 1)[0]
+    )
+
+
+def selector_script():
+    return textwrap.dedent(
+        step_source("Generate pull request details").split("        run: |\n", 1)[1]
+    )
+
+
+def pr(number=1, version="7.63.0", branch="posthoganalytics-7.63.0", **kwargs):
+    return {
+        "number": number,
+        "title": TITLE_PREFIX + version,
+        "headRefName": branch,
+        "headRepositoryOwner": {"login": "PostHog"},
+        "isCrossRepository": False,
+        "createdAt": number,
+        **kwargs,
+    }
+
+
+def comments(*statuses):
+    return [[{"user": {"login": "trunk-io[bot]"}, "body": s} for s in statuses]]
+
+
+# Execute the workflow's jq filters, not an alternate implementation of them.
+# The fake provider sorts only when the request explicitly asks it to.
+GH_MOCK = r"""
+import json
+import os
+import subprocess
+import sys
+
+args = sys.argv[1:]
+with open(os.environ["MOCK_CALLS"], "a") as file:
+    file.write(json.dumps(args) + "\n")
+fixture = json.loads(os.environ["MOCK_FIXTURE"])
+if args[:2] == ["pr", "list"]:
+    assert args[args.index("--repo") + 1] == "PostHog/posthog"
+    assert args[args.index("--state") + 1] == "open"
+    records = fixture["prs"]
+    if "--head" in args:
+        if fixture.get("fallback_fail"):
+            sys.exit(1)
+        head = args[args.index("--head") + 1]
+        records = [p for p in records if p["headRefName"] == head]
+    else:
+        if fixture.get("list_fail"):
+            sys.exit(1)
+        assert args.index("--search") < args.index("--limit")
+        search = args[args.index("--search") + 1]
+        assert '"chore(deps): update posthoganalytics to " in:title' in search
+        if "sort:created-desc" in search:
+            records = sorted(records, key=lambda p: p["createdAt"], reverse=True)
+    records = records[:int(args[args.index("--limit") + 1])]
+elif args[0] == "api":
+    assert "--paginate" in args and "--slurp" in args
+    number = args[1].split("/")[4]
+    if int(number) in fixture.get("api_fail", []):
+        sys.exit(1)
+    records = fixture.get("comments", {}).get(number, [[]])
+else:
+    raise AssertionError("Unexpected GitHub call: " + repr(args))
+result = subprocess.run(
+    ["jq", "-r", args[args.index("--jq") + 1]],
+    input=json.dumps(records), text=True, capture_output=True, check=True,
+)
+sys.stdout.write(result.stdout)
+"""
+
+UV_MOCK = """
+import os
+import sys
+
+assert sys.argv[1:6] == ["run", "--no-project", "--with", "packaging==25.0", "python"]
+os.execv(sys.executable, [sys.executable, *sys.argv[6:]])
+"""
+
+
+@pytest.fixture
+def select(tmp_path):
+    missing = [tool for tool in ("bash", "jq") if shutil.which(tool) is None]
+    if missing:
+        pytest.skip(
+            f"Install {', '.join(missing)} and make it available on PATH "
+            "to run the workflow shell-entry tests."
+        )
+
+    for name, source in [("gh", GH_MOCK), ("uv", UV_MOCK)]:
+        executable = tmp_path / name
+        executable.write_text(f"#!{sys.executable}\n" + source)
+        executable.chmod(0o755)
+
+    def run(prs=(), version="7.64.1", **fixture):
+        output = tmp_path / "output"
+        output.write_text("")
+        calls = tmp_path / "calls"
+        calls.write_text("")
+        env = {
+            **os.environ,
+            "PATH": f"{tmp_path}{os.pathsep}{os.environ['PATH']}",
+            "PACKAGE_NAME": "posthoganalytics",
+            "PACKAGE_VERSION": version,
+            "GITHUB_OUTPUT": str(output),
+            "MOCK_CALLS": str(calls),
+            "MOCK_FIXTURE": json.dumps({"prs": prs, **fixture}),
+        }
+        result = subprocess.run(
+            [
+                "bash",
+                "--noprofile",
+                "--norc",
+                "-e",
+                "-o",
+                "pipefail",
+                "-c",
+                selector_script(),
+            ],
+            env=env,
+            text=True,
+            capture_output=True,
+            timeout=15,
+        )
+        requests = [json.loads(line) for line in calls.read_text().splitlines()]
+        # Every scenario must use explicit chronological search, including skips.
+        assert "sort:created-desc" in requests[0][requests[0].index("--search") + 1]
+        return result, output.read_text(), requests
+
+    return run
+
+
+def assert_branch(result, branch, version="7.64.1"):
+    process, output, _ = result
+    assert process.returncode == 0, process.stderr
+    assert "skip=false\n" in output
+    assert f"branch_name={branch}\n" in output
+    assert f"title={TITLE_PREFIX}{version}\n" in output
+    assert f"PostHog Python SDK version {version} has been released." in output
+    assert "`posthoganalytics` and `posthog`" in output
+
+
+def assert_skip(result):
+    process, output, _ = result
+    assert process.returncode == 0, process.stderr
+    assert output == "skip=true\n"
+
+
+def assert_failure(result):
+    process, output, _ = result
+    assert process.returncode != 0
+    assert output == ""
+
+
+@pytest.mark.parametrize(
+    "prs,branch",
+    [
+        ([], "posthoganalytics-upgrade"),
+        ([pr()], "posthoganalytics-7.63.0"),
+        ([pr(branch="posthoganalytics-upgrade")], "posthoganalytics-upgrade"),
+        ([pr(headRepositoryOwner={"login": "someone"})], "posthoganalytics-upgrade"),
+        ([pr(title="chore(deps): update other to 1.0.0")], "posthoganalytics-upgrade"),
+    ],
+    ids=["no-pr", "legacy-branch", "stable-branch", "fork", "other-package"],
+)
+def test_branch_selection(select, prs, branch):
+    assert_branch(select(prs), branch)
+
+
+@pytest.mark.parametrize("status", [RUNNING, WAITING])
+def test_queued_selected_pr_uses_version_branch(select, status):
+    assert_branch(select([pr()], comments={"1": comments(status)}), FALLBACK)
+
+
+def test_unknown_selected_queue_status_checks_fallback(select):
+    result = select([pr()], api_fail=[1])
+    assert_branch(result, FALLBACK)
+    assert any("--head" in call for call in result[2])
+
+
+def test_pr_lookup_failure_fails_safely(select):
+    assert_failure(select(list_fail=True))
+
+
+@pytest.mark.parametrize(
+    "incoming,current,skip",
+    [
+        ("7.10", "7.9", False),
+        ("7.9", "7.10", True),
+        ("7.64.1", "7.64.1", False),
+        ("7.64.1.0", "7.64.1", False),
+        ("7.64.1", "7.64.1rc1", False),
+        ("7.64.1rc1", "7.64.1", True),
+        ("7.64.1rc2", "7.64.1rc1", False),
+        ("7.64.1rc1", "7.64.1rc2", True),
+    ],
+)
+def test_pep440_version_ordering(select, incoming, current, skip):
+    result = select([pr(version=current)], version=incoming)
+    if skip:
+        assert_skip(result)
+    else:
+        assert_branch(result, "posthoganalytics-7.63.0", incoming)
+
+
+@pytest.mark.parametrize(
+    "incoming,current", [("7.64.1", "unknown"), ("unknown", "7.64.1"), ("7.64.1", "")]
+)
+def test_unparseable_comparison_fails_safely(select, incoming, current):
+    assert_failure(select([pr(version=current)], version=incoming))
+
+
+def test_newer_run_then_older_rerun_preserves_shared_branch_version(select):
+    existing = pr(branch="posthoganalytics-upgrade")
+    assert_branch(select([existing]), existing["headRefName"])
+    existing["title"] = TITLE_PREFIX + "7.64.1"  # Metadata after the newer run.
+    assert_skip(select([existing], version="7.64.0"))
+    assert existing["title"] == TITLE_PREFIX + "7.64.1"
+
+
+def test_different_versions_share_reusable_branch(select):
+    existing = pr(branch="posthoganalytics-upgrade")
+    for version in ["7.64.0", "7.64.1"]:
+        assert_branch(
+            select([existing], version=version), existing["headRefName"], version
+        )
+
+
+def test_older_run_skips_even_if_newer_selected_pr_is_queued(select):
+    assert_skip(select([pr(version="7.64.2")], comments={"1": comments(RUNNING)}))
+
+
+@pytest.mark.parametrize("unknown", [False, True], ids=["queued", "unknown"])
+def test_same_version_fallback_is_protected(select, unknown):
+    result = select(
+        [pr(version="7.64.1", branch=FALLBACK)],
+        comments={"1": comments(RUNNING)},
+        api_fail=[1] if unknown else [],
+    )
+    assert_skip(result)
+    assert any("--head" in call for call in result[2])
+
+
+@pytest.mark.parametrize("unknown", [False, True], ids=["queued", "unknown"])
+def test_older_fallback_collision_is_independently_protected(select, unknown):
+    result = select(
+        [pr(branch=FALLBACK), pr(2, version="7.64.1", branch="newest")],
+        comments={"1": comments(RUNNING), "2": comments(WAITING)},
+        api_fail=[1] if unknown else [],
+    )
+    assert_skip(result)
+    apis = [call[1] for call in result[2] if call[0] == "api"]
+    assert apis == [
+        "repos/PostHog/posthog/issues/2/comments?per_page=100",
+        "repos/PostHog/posthog/issues/1/comments?per_page=100",
+    ]
+
+
+def test_fallback_lookup_failure_skips(select):
+    assert_skip(select([pr()], comments={"1": comments(RUNNING)}, fallback_fail=True))
+
+
+def test_unqueued_fallback_is_reused(select):
+    assert_branch(
+        select(
+            [pr(branch=FALLBACK), pr(2, version="7.64.1", branch="newest")],
+            comments={
+                "1": comments(RUNNING, "Removed from queue"),
+                "2": comments(RUNNING),
+            },
+        ),
+        FALLBACK,
+    )
+
+
+@pytest.mark.parametrize("current", ["7.64.2", "invalid", ""])
+def test_fallback_destination_version_is_checked(select, current):
+    result = select(
+        [pr(version=current, branch=FALLBACK), pr(2, branch="newest")],
+        comments={"2": comments(RUNNING)},
+    )
+    if current == "7.64.2":
+        assert_skip(result)
+    else:
+        assert_failure(result)
+
+
+def test_fallback_with_unrecognized_title_fails_safely(select):
+    assert_failure(
+        select(
+            [pr(branch=FALLBACK, title="Another change"), pr(2, branch="newest")],
+            comments={"2": comments(RUNNING)},
+        )
+    )
+
+
+def test_fallback_lookup_ignores_cross_repository_pr(select):
+    assert_branch(
+        select(
+            [pr(branch=FALLBACK, isCrossRepository=True), pr(2, branch="newest")],
+            comments={"1": comments(RUNNING), "2": comments(RUNNING)},
+        ),
+        FALLBACK,
+    )
+
+
+def test_search_orders_before_newest_only_queue_selection(select):
+    result = select([pr(1, branch="older"), pr(2, branch="newest")])
+    assert_branch(result, "newest")
+    assert [call[1] for call in result[2] if call[0] == "api"] == [
+        "repos/PostHog/posthog/issues/2/comments?per_page=100"
+    ]
+
+
+@pytest.mark.parametrize("cleared", [False, True])
+def test_queue_comments_are_paginated_and_latest_trunk_status_wins(select, cleared):
+    pages = comments(RUNNING)
+    pages[0].extend([{"user": {"login": "someone"}, "body": RUNNING}] * 99)
+    pages += comments("Removed from queue" if cleared else WAITING)
+    assert_branch(
+        select([pr()], comments={"1": pages}),
+        "posthoganalytics-7.63.0" if cleared else FALLBACK,
+    )
+
+
+def test_other_commenters_do_not_determine_queue_status(select):
+    assert_branch(
+        select(
+            [pr()], comments={"1": [[{"user": {"login": "someone"}, "body": RUNNING}]]}
+        ),
+        "posthoganalytics-7.63.0",
+    )
+
+
+def test_writers_share_non_cancelling_package_concurrency():
+    source = WORKFLOW.read_text()
+    concurrency = source.split("\nconcurrency:\n", 1)[1].split("\njobs:", 1)[0]
+    assert (
+        "group: posthog-upgrade-${{ github.event.inputs.package_name }}" in concurrency
+    )
+    assert "cancel-in-progress: false" in concurrency
+
+
+def test_remote_mutations_are_gated_and_use_selector_outputs():
+    for name in [
+        "Create main repo pull request",
+        "Update pull request metadata",
+        "Assign reviewers",
+    ]:
+        assert "if: steps.generate-pr-details.outputs.skip == 'false'" in step_source(
+            name
+        )
+    create = step_source("Create main repo pull request")
+    for field, output in [
+        ("branch", "branch_name"),
+        ("title", "title"),
+        ("body", "body"),
+    ]:
+        assert (
+            f"{field}: ${{{{ steps.generate-pr-details.outputs.{output} }}}}" in create
+        )
+    metadata = step_source("Update pull request metadata")
+    assert "PR_TITLE: ${{ steps.generate-pr-details.outputs.title }}" in metadata
+    assert "PR_BODY: ${{ steps.generate-pr-details.outputs.body }}" in metadata

From 6d6cc3dac989569f3c571308e4db9b9f6ecf7b36 Mon Sep 17 00:00:00 2001
From: Hugues Pouillot <hpouillot@gmail.com>
Date: Thu, 8 Oct 2026 12:28:52 +0200
Subject: [PATCH 002/245] feat(error-tracking): standardize exception event
 metadata (#898)

* feat(error-tracking): standardize exception metadata

* fix(error-tracking): preserve explicit trace context

* fix(error-tracking): restrict exception group traversal

* fix(error-tracking): deprecate reserved property overrides

* fix(error-tracking): bound exception group traversal
---
 .../canonical-exception-metadata.md           |   5 +
 posthog/__init__.py                           |   2 +
 posthog/client.py                             |  61 ++++-
 posthog/exception_capture.py                  |  50 +++-
 posthog/exception_utils.py                    | 249 ++++++++++++------
 posthog/integrations/celery.py                |  15 +-
 posthog/integrations/django.py                |  15 +-
 .../integrations/test_celery_integration.py   |  27 +-
 posthog/test/integrations/test_middleware.py  |  18 +-
 posthog/test/snapshots/exception_event.json   |  10 +-
 posthog/test/test_client.py                   |  39 +++
 posthog/test/test_exception_capture.py        | 144 +++++++++-
 12 files changed, 535 insertions(+), 100 deletions(-)
 create mode 100644 .sampo/changesets/canonical-exception-metadata.md

diff --git a/.sampo/changesets/canonical-exception-metadata.md b/.sampo/changesets/canonical-exception-metadata.md
new file mode 100644
index 000000000..ea67a36e4
--- /dev/null
+++ b/.sampo/changesets/canonical-exception-metadata.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Standardize exception capture metadata, including severity, capture source, typed integration metadata, mechanism semantics, bounded exception-group traversal, and deterministic cause linkage. Application overrides of reserved exception properties remain supported during a deprecation period, emit a warning, and will be removed in the next major version.
diff --git a/posthog/__init__.py b/posthog/__init__.py
index 5d6ae1193..d718906f0 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -731,6 +731,8 @@ def capture_exception(
         exception: The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`
         **kwargs: Optional capture arguments including distinct_id, properties,
             timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.
+            Overriding reserved exception properties through ``properties`` is
+            deprecated and will stop working in the next major version.
 
     Details:
         Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the "traceback"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError("Some Error"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.
diff --git a/posthog/client.py b/posthog/client.py
index 2bb16c492..d74ea56e3 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -65,6 +65,7 @@
     _get_current_otel_span_properties,
     handle_in_app,
     mark_exception_as_captured,
+    _normalize_exception_level,
     try_attach_code_variables_to_frames,
 )
 from posthog.feature_flag_evaluations import (
@@ -2088,7 +2089,9 @@ def capture_exception(
         Args:
             exception: The exception to capture.
             distinct_id: The distinct ID of the user.
-            properties: A dictionary of additional properties.
+            properties: A dictionary of additional properties. Overriding reserved
+                exception properties is deprecated and will stop working in the next
+                major version.
             flags: A ``FeatureFlagEvaluations`` snapshot from ``evaluate_flags()``.
                 Attaches those exact flag values to the captured `$exception` event.
             send_feature_flags: Deprecated. Pass ``flags`` from ``evaluate_flags()`` instead.
@@ -2131,7 +2134,16 @@ def capture_exception(
                 return None
 
             # Format stack trace for cymbal
-            all_exceptions_with_trace = exceptions_from_error_tuple(exc_info)
+            capture_metadata_input = dict(kwargs).get("_capture_metadata")
+            capture_metadata = (
+                capture_metadata_input
+                if isinstance(capture_metadata_input, dict)
+                else {}
+            )
+            mechanism = capture_metadata.get("mechanism")
+            all_exceptions_with_trace = exceptions_from_error_tuple(
+                exc_info, mechanism=mechanism if isinstance(mechanism, dict) else None
+            )
 
             # Add in-app property to frames in the exceptions
             event = handle_in_app(
@@ -2145,11 +2157,52 @@ def capture_exception(
             )
             all_exceptions_with_trace_and_in_app = event["exception"]["values"]
 
+            reserved_properties = {
+                "$exception_list",
+                "$exception_level",
+                "$exception_source",
+                "$debug_images",
+                "$exception_handled",
+                "$exception_types",
+                "$exception_values",
+                "$exception_sources",
+                "$exception_functions",
+                "$exception_fingerprint_version",
+                "$exception_fingerprint_record",
+                "$exception_issue_id",
+                "$exception_release",
+                "$cymbal_errors",
+            }
+            reserved_property_overrides = reserved_properties.intersection(properties)
+            if reserved_property_overrides:
+                try:
+                    warnings.warn(
+                        "Reserved exception properties passed through "
+                        "`capture_exception(properties=...)` currently override "
+                        "SDK-owned metadata, but this behavior is deprecated and will "
+                        "be removed in the next major version: "
+                        + ", ".join(sorted(reserved_property_overrides)),
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                except DeprecationWarning:
+                    # capture_exception must not drop an event when applications
+                    # promote deprecation warnings to errors.
+                    pass
+
+            caller_properties = properties
             properties = {
-                "$exception_list": all_exceptions_with_trace_and_in_app,
                 **_get_current_otel_span_properties(),
-                **properties,
+                "$exception_list": all_exceptions_with_trace_and_in_app,
+                "$exception_level": _normalize_exception_level(
+                    capture_metadata.get("level")
+                )
+                or "error",
             }
+            source = capture_metadata.get("source")
+            if isinstance(source, str) and source:
+                properties["$exception_source"] = source
+            properties.update(caller_properties)
 
             context_enabled = get_capture_exception_code_variables_context()
             context_mask = get_code_variables_mask_patterns_context()
diff --git a/posthog/exception_capture.py b/posthog/exception_capture.py
index 9c4c723a9..6dac4057f 100644
--- a/posthog/exception_capture.py
+++ b/posthog/exception_capture.py
@@ -7,9 +7,13 @@
 import logging
 import sys
 import threading
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from posthog.bucketed_rate_limiter import BucketedRateLimiter
+from .exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+)
 
 if TYPE_CHECKING:
     from posthog.client import Client
@@ -80,7 +84,18 @@ def close(self):
 
     def exception_handler(self, exc_type, exc_value, exc_traceback):
         if not self._closed:
-            self.capture_exception((exc_type, exc_value, exc_traceback))
+            capture_metadata: _ExceptionCaptureMetadata = {
+                "level": "fatal",
+                "source": "python.sys_excepthook",
+                "mechanism": {
+                    "type": "onuncaughtexception",
+                    "handled": False,
+                },
+            }
+            self._capture_exception(
+                (exc_type, exc_value, exc_traceback),
+                capture_metadata=capture_metadata,
+            )
         previous_hook = self._resolve_hook(
             self.original_excepthook,
             "exception_handler",
@@ -90,7 +105,18 @@ def exception_handler(self, exc_type, exc_value, exc_traceback):
 
     def thread_exception_handler(self, args):
         if not self._closed:
-            self.capture_exception((args.exc_type, args.exc_value, args.exc_traceback))
+            capture_metadata: _ExceptionCaptureMetadata = {
+                "level": "error",
+                "source": "python.threading_excepthook",
+                "mechanism": {
+                    "type": "onuncaughtexception",
+                    "handled": False,
+                },
+            }
+            self._capture_exception(
+                (args.exc_type, args.exc_value, args.exc_traceback),
+                capture_metadata=capture_metadata,
+            )
         previous_hook = self._resolve_hook(
             self._original_threading_excepthook,
             "thread_exception_handler",
@@ -117,6 +143,14 @@ def exception_receiver(self, exc_info, extra_properties):
         self.capture_exception((exc_info[0], exc_info[1], exc_info[2]), metadata)
 
     def capture_exception(self, exception, metadata=None):
+        self._capture_exception(exception, metadata)
+
+    def _capture_exception(
+        self,
+        exception,
+        metadata=None,
+        capture_metadata: Optional[_ExceptionCaptureMetadata] = None,
+    ):
         try:
             if self._rate_limiter is not None:
                 exception_type = self._exception_type(exception)
@@ -127,7 +161,15 @@ def capture_exception(self, exception, metadata=None):
                     return
 
             distinct_id = metadata.get("distinct_id") if metadata else None
-            self.client.capture_exception(exception, distinct_id=distinct_id)
+            resolved_capture_metadata: _ExceptionCaptureMetadata = (
+                capture_metadata or {}
+            )
+            _capture_exception_with_metadata(
+                self.client,
+                exception,
+                resolved_capture_metadata,
+                distinct_id=distinct_id,
+            )
         except Exception as e:
             self.log.exception(f"Failed to capture exception: {e}")
 
diff --git a/posthog/exception_utils.py b/posthog/exception_utils.py
index c0bb345d1..8608b96f0 100644
--- a/posthog/exception_utils.py
+++ b/posthog/exception_utils.py
@@ -571,6 +571,74 @@ def get_error_message(exc_value):
     return safe_str(message)
 
 
+def _valid_mechanism(mechanism):
+    # type: (Optional[Dict[str, Any]]) -> Dict[str, Any]
+    """Validate common mechanism fields without dropping safe extensions."""
+    if not isinstance(mechanism, dict):
+        return {}
+
+    result = {
+        key: value
+        for key, value in mechanism.items()
+        if key
+        not in {"type", "handled", "source", "synthetic", "exception_id", "parent_id"}
+    }
+    if isinstance(mechanism.get("type"), str) and mechanism["type"]:
+        result["type"] = mechanism["type"]
+    if isinstance(mechanism.get("handled"), bool):
+        result["handled"] = mechanism["handled"]
+    if isinstance(mechanism.get("source"), str) and mechanism["source"]:
+        result["source"] = mechanism["source"]
+    if isinstance(mechanism.get("synthetic"), bool):
+        result["synthetic"] = mechanism["synthetic"]
+    return result
+
+
+class _ExceptionMechanismMetadata(TypedDict, total=False):
+    """Typed common mechanism fields accepted from SDK-owned integrations."""
+
+    type: str
+    handled: bool
+    source: str
+    synthetic: bool
+
+
+class _ExceptionCaptureMetadata(TypedDict, total=False):
+    """Typed capture-boundary metadata for SDK-owned integrations."""
+
+    level: Literal["fatal", "error", "warning", "log", "info", "debug"]
+    source: str
+    mechanism: _ExceptionMechanismMetadata
+
+
+_EXCEPTION_LEVELS = {
+    "fatal": "fatal",
+    "critical": "fatal",
+    "alert": "fatal",
+    "emergency": "fatal",
+    "error": "error",
+    "warning": "warning",
+    "warn": "warning",
+    "log": "log",
+    "notice": "info",
+    "info": "info",
+    "trace": "debug",
+    "debug": "debug",
+}
+
+
+def _normalize_exception_level(level):
+    # type: (Any) -> Optional[str]
+    return _EXCEPTION_LEVELS.get(level.lower()) if isinstance(level, str) else None
+
+
+def _capture_exception_with_metadata(client, exception, capture_metadata, **kwargs):
+    # type: (Any, ExceptionArg, _ExceptionCaptureMetadata, **Any) -> Optional[str]
+    """Call capture_exception through the SDK-internal typed integration channel."""
+    capture = client.capture_exception  # type: Any
+    return capture(exception, _capture_metadata=capture_metadata, **kwargs)
+
+
 def single_exception_from_error_tuple(
     exc_type,  # type: Optional[type]
     exc_value,  # type: Optional[BaseException]
@@ -585,9 +653,7 @@ def single_exception_from_error_tuple(
     Creates a dict that goes into the events `exception.values` list
     """
     exception_value = {}  # type: Dict[str, Any]
-    exception_value["mechanism"] = (
-        mechanism.copy() if mechanism else {"type": "generic", "handled": True}
-    )
+    exception_value["mechanism"] = _valid_mechanism(mechanism)
     if exception_id is not None:
         exception_value["mechanism"]["exception_id"] = exception_id
 
@@ -601,16 +667,23 @@ def single_exception_from_error_tuple(
             "errno", {}
         ).setdefault("number", errno)
 
-    if source is not None:
+    if isinstance(source, str) and source:
         exception_value["mechanism"]["source"] = source
 
     is_root_exception = exception_id == 0
     if not is_root_exception and parent_id is not None:
         exception_value["mechanism"]["parent_id"] = parent_id
         exception_value["mechanism"]["type"] = "chained"
+        exception_value["mechanism"].pop("handled", None)
 
-    if is_root_exception and "type" not in exception_value["mechanism"]:
-        exception_value["mechanism"]["type"] = "generic"
+    if is_root_exception:
+        exception_value["mechanism"].setdefault("type", "generic")
+        exception_value["mechanism"].setdefault("handled", True)
+        exception_value["mechanism"].pop("source", None)
+
+    # Python capture inputs are runtime exceptions and this builder never
+    # replaces their stack with an SDK-generated current stack.
+    exception_value["mechanism"].setdefault("synthetic", False)
 
     is_exception_group = BaseExceptionGroup is not None and isinstance(
         exc_value, BaseExceptionGroup
@@ -680,7 +753,17 @@ def walk_exception_chain(exc_info):
         yield exc_info
 
 
-def exceptions_from_error(
+_MAX_EXCEPTION_ENTRIES = 50
+_MAX_EXCEPTION_GROUP_MEMBER_INSPECTIONS = 1_000
+
+
+@dataclasses.dataclass
+class _ExceptionTraversalState:
+    seen_exception_ids: Set[int] = dataclasses.field(default_factory=set)
+    inspected_group_members: int = 0
+
+
+def _exceptions_from_error(
     exc_type,  # type: Optional[type]
     exc_value,  # type: Optional[BaseException]
     tb,  # type: Optional[TracebackType]
@@ -688,12 +771,20 @@ def exceptions_from_error(
     exception_id=0,  # type: int
     parent_id=0,  # type: int
     source=None,  # type: Optional[str]
+    traversal_state=None,  # type: Optional[_ExceptionTraversalState]
 ):
     # type: (...) -> Tuple[int, List[Dict[str, Any]]]
-    """
-    Creates the list of exceptions.
-    This can include chained exceptions and exceptions from an ExceptionGroup.
-    """
+    """Build a bounded, depth-first flattened exception tree."""
+
+    if traversal_state is None:
+        traversal_state = _ExceptionTraversalState()
+    if exc_value is not None:
+        if (
+            id(exc_value) in traversal_state.seen_exception_ids
+            or exception_id >= _MAX_EXCEPTION_ENTRIES
+        ):
+            return (exception_id, [])
+        traversal_state.seen_exception_ids.add(id(exc_value))
 
     parent = single_exception_from_error_tuple(
         exc_type=exc_type,
@@ -709,67 +800,89 @@ def exceptions_from_error(
     parent_id = exception_id
     exception_id += 1
 
-    should_supress_context = (
+    causing_exception = None  # type: Optional[BaseException]
+    relationship = None  # type: Optional[str]
+    should_suppress_context = (
         hasattr(exc_value, "__suppress_context__") and exc_value.__suppress_context__  # type: ignore
     )
-    if should_supress_context:
-        # Add direct cause.
-        # The field `__cause__` is set when raised with the exception (using the `from` keyword).
-        exception_has_cause = (
-            exc_value
-            and hasattr(exc_value, "__cause__")
-            and exc_value.__cause__ is not None
-        )
-        if exception_has_cause:
-            cause = exc_value.__cause__  # type: ignore
-            (exception_id, child_exceptions) = exceptions_from_error(
-                exc_type=type(cause),
-                exc_value=cause,
-                tb=getattr(cause, "__traceback__", None),
-                mechanism=mechanism,
-                exception_id=exception_id,
-                source="__cause__",
-            )
-            exceptions.extend(child_exceptions)
-
+    if should_suppress_context and exc_value is not None:
+        causing_exception = getattr(exc_value, "__cause__", None)
+        relationship = "cause"
     else:
-        # Add indirect cause.
-        # The field `__context__` is assigned if another exception occurs while handling the exception.
-        exception_has_content = (
-            exc_value
-            and hasattr(exc_value, "__context__")
-            and exc_value.__context__ is not None
+        causing_exception = getattr(exc_value, "__context__", None)
+        relationship = "context"
+
+    if causing_exception is not None and exception_id < _MAX_EXCEPTION_ENTRIES:
+        (exception_id, child_exceptions) = _exceptions_from_error(
+            exc_type=type(causing_exception),
+            exc_value=causing_exception,
+            tb=getattr(causing_exception, "__traceback__", None),
+            mechanism=None,
+            exception_id=exception_id,
+            parent_id=parent_id,
+            source=relationship,
+            traversal_state=traversal_state,
         )
-        if exception_has_content:
-            context = exc_value.__context__  # type: ignore
-            (exception_id, child_exceptions) = exceptions_from_error(
-                exc_type=type(context),
-                exc_value=context,
-                tb=getattr(context, "__traceback__", None),
-                mechanism=mechanism,
-                exception_id=exception_id,
-                source="__context__",
-            )
-            exceptions.extend(child_exceptions)
+        exceptions.extend(child_exceptions)
 
-    # Add exceptions from an ExceptionGroup.
-    is_exception_group = exc_value and hasattr(exc_value, "exceptions")
+    # Aggregate-member inspection has its own shared budget. Duplicate and cyclic
+    # references still consume it even though they do not produce output entries.
+    # Cause/context traversal does not consume this budget, so the final inspected
+    # member can retain its complete cause chain within the output limit.
+    is_exception_group = BaseExceptionGroup is not None and isinstance(
+        exc_value, BaseExceptionGroup
+    )
     if is_exception_group:
-        for idx, e in enumerate(exc_value.exceptions):  # type: ignore
-            (exception_id, child_exceptions) = exceptions_from_error(
+        members = exc_value.exceptions  # type: ignore
+        member_index = 0
+        while (
+            member_index < len(members)
+            and exception_id < _MAX_EXCEPTION_ENTRIES
+            and traversal_state.inspected_group_members
+            < _MAX_EXCEPTION_GROUP_MEMBER_INSPECTIONS
+        ):
+            # Charge before reading the member, as required by the canonical
+            # exception metadata traversal contract.
+            traversal_state.inspected_group_members += 1
+            e = members[member_index]
+            member_index += 1
+            (exception_id, child_exceptions) = _exceptions_from_error(
                 exc_type=type(e),
                 exc_value=e,
                 tb=getattr(e, "__traceback__", None),
-                mechanism=mechanism,
+                mechanism=None,
                 exception_id=exception_id,
                 parent_id=parent_id,
-                source="exceptions[%s]" % idx,
+                source="member",
+                traversal_state=traversal_state,
             )
             exceptions.extend(child_exceptions)
 
     return (exception_id, exceptions)
 
 
+def exceptions_from_error(
+    exc_type,  # type: Optional[type]
+    exc_value,  # type: Optional[BaseException]
+    tb,  # type: Optional[TracebackType]
+    mechanism=None,  # type: Optional[Dict[str, Any]]
+    exception_id=0,  # type: int
+    parent_id=0,  # type: int
+    source=None,  # type: Optional[str]
+):
+    # type: (...) -> Tuple[int, List[Dict[str, Any]]]
+    """Compatibility wrapper around the bounded exception-tree traversal."""
+    return _exceptions_from_error(
+        exc_type,
+        exc_value,
+        tb,
+        mechanism=mechanism,
+        exception_id=exception_id,
+        parent_id=parent_id,
+        source=source,
+    )
+
+
 def exceptions_from_error_tuple(
     exc_info,  # type: ExcInfo
     mechanism=None,  # type: Optional[Dict[str, Any]]
@@ -777,27 +890,15 @@ def exceptions_from_error_tuple(
     # type: (...) -> List[Dict[str, Any]]
     exc_type, exc_value, tb = exc_info
 
-    is_exception_group = BaseExceptionGroup is not None and isinstance(
-        exc_value, BaseExceptionGroup
+    (_, exceptions) = _exceptions_from_error(
+        exc_type=exc_type,
+        exc_value=exc_value,
+        tb=tb,
+        mechanism=mechanism,
+        exception_id=0,
+        parent_id=0,
     )
 
-    if is_exception_group:
-        (_, exceptions) = exceptions_from_error(
-            exc_type=exc_type,
-            exc_value=exc_value,
-            tb=tb,
-            mechanism=mechanism,
-            exception_id=0,
-            parent_id=0,
-        )
-
-    else:
-        exceptions = []
-        for exc_type, exc_value, tb in walk_exception_chain(exc_info):
-            exceptions.append(
-                single_exception_from_error_tuple(exc_type, exc_value, tb, mechanism)
-            )
-
     # Canonical ordering: $exception_list[0] is the caught/outermost exception,
     # with each cause appended after its wrapper in unwrap order and the root
     # cause last. Both branches above already build the list in this order
diff --git a/posthog/integrations/celery.py b/posthog/integrations/celery.py
index bcd7b140f..59a513be4 100644
--- a/posthog/integrations/celery.py
+++ b/posthog/integrations/celery.py
@@ -67,10 +67,14 @@
 import json
 import logging
 import time
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, cast
 
 from .. import contexts
 from ..client import Client
+from ..exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+)
 
 
 CONTEXT_DISTINCT_ID_HEADER = "X-POSTHOG-DISTINCT-ID"
@@ -475,12 +479,17 @@ def _capture_event(self, event: str, properties: dict[str, Any]) -> None:
             capture(event, properties=properties)
 
     def _capture_exception(self, exception: Exception) -> None:
+        capture_metadata: _ExceptionCaptureMetadata = {
+            "level": "error",
+            "source": "celery.task_failure",
+            "mechanism": {"type": "task", "handled": False},
+        }
         if self.client:
-            self.client.capture_exception(exception)
+            _capture_exception_with_metadata(self.client, exception, capture_metadata)
         else:
             from posthog import capture_exception
 
-            capture_exception(exception)
+            cast(Any, capture_exception)(exception, _capture_metadata=capture_metadata)
 
 
 __all__ = [
diff --git a/posthog/integrations/django.py b/posthog/integrations/django.py
index 6eba55058..0347c6b86 100644
--- a/posthog/integrations/django.py
+++ b/posthog/integrations/django.py
@@ -1,8 +1,12 @@
 import re
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from .. import contexts
 from ..client import Client
+from ..exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+)
 
 try:
     from asgiref.sync import iscoroutinefunction, markcoroutinefunction
@@ -362,9 +366,14 @@ def process_exception(self, request, exception):
 
         # Context and tags already set by __call__ or __acall__
         # Just capture the exception
+        capture_metadata: _ExceptionCaptureMetadata = {
+            "level": "error",
+            "source": "django.middleware",
+            "mechanism": {"type": "middleware", "handled": False},
+        }
         if self.client:
-            self.client.capture_exception(exception)
+            _capture_exception_with_metadata(self.client, exception, capture_metadata)
         else:
             from posthog import capture_exception
 
-            capture_exception(exception)
+            cast(Any, capture_exception)(exception, _capture_metadata=capture_metadata)
diff --git a/posthog/test/integrations/test_celery_integration.py b/posthog/test/integrations/test_celery_integration.py
index 565800cac..0e06314eb 100644
--- a/posthog/test/integrations/test_celery_integration.py
+++ b/posthog/test/integrations/test_celery_integration.py
@@ -424,7 +424,14 @@ def test_task_failure_captures_exception_and_failure_event(self):
             exception=exception,
         )
 
-        mock_client.capture_exception.assert_called_once_with(exception)
+        mock_client.capture_exception.assert_called_once_with(
+            exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "celery.task_failure",
+                "mechanism": {"type": "task", "handled": False},
+            },
+        )
         event_names = [call.args[0] for call in mock_client.capture.call_args_list]
         self.assertIn("celery task failure", event_names)
 
@@ -588,7 +595,14 @@ def test_task_failure_captures_exception_when_lifecycle_events_disabled(self):
         )
 
         mock_client.capture.assert_not_called()
-        mock_client.capture_exception.assert_called_once_with(exception)
+        mock_client.capture_exception.assert_called_once_with(
+            exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "celery.task_failure",
+                "mechanism": {"type": "task", "handled": False},
+            },
+        )
 
     def test_after_task_publish_captures_published_event(self):
         mock_client = Mock()
@@ -656,7 +670,14 @@ def test_capture_exception_falls_back_to_global_capture_exception(self):
         with patch("posthog.capture_exception") as mock_capture_exception:
             integration._capture_exception(exception)
 
-        mock_capture_exception.assert_called_once_with(exception)
+        mock_capture_exception.assert_called_once_with(
+            exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "celery.task_failure",
+                "mechanism": {"type": "task", "handled": False},
+            },
+        )
 
     def test_extract_headers_supports_request_dict_shape(self):
         integration = PosthogCeleryIntegration()
diff --git a/posthog/test/integrations/test_middleware.py b/posthog/test/integrations/test_middleware.py
index 1d4e26089..c76a8779a 100644
--- a/posthog/test/integrations/test_middleware.py
+++ b/posthog/test/integrations/test_middleware.py
@@ -309,7 +309,14 @@ def mock_get_response(request):
         response = middleware(request)
 
         self.assertEqual(response.status_code, 500)
-        mock_client.capture_exception.assert_called_once_with(view_exception)
+        mock_client.capture_exception.assert_called_once_with(
+            view_exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "django.middleware",
+                "mechanism": {"type": "middleware", "handled": False},
+            },
+        )
 
     def test_process_exception_respects_capture_exceptions_false(self):
         """Verify process_exception respects capture_exceptions=False setting"""
@@ -445,7 +452,14 @@ def get_response_simulating_django(request):
         if hasattr(middleware, "process_exception"):
             exception = ValueError("View error")
             middleware.process_exception(request, exception)
-            mock_client.capture_exception.assert_called_once_with(exception)
+            mock_client.capture_exception.assert_called_once_with(
+                exception,
+                _capture_metadata={
+                    "level": "error",
+                    "source": "django.middleware",
+                    "mechanism": {"type": "middleware", "handled": False},
+                },
+            )
         else:
             self.fail(
                 "process_exception missing - view exceptions will not be captured!"
diff --git a/posthog/test/snapshots/exception_event.json b/posthog/test/snapshots/exception_event.json
index b971c7afe..aef9d628e 100644
--- a/posthog/test/snapshots/exception_event.json
+++ b/posthog/test/snapshots/exception_event.json
@@ -6,10 +6,13 @@
         "distinct_id": "user-123",
         "event": "$exception",
         "properties": {
+          "$exception_level": "error",
           "$exception_list": [
             {
               "mechanism": {
+                "exception_id": 0,
                 "handled": true,
+                "synthetic": false,
                 "type": "generic"
               },
               "module": null,
@@ -71,8 +74,11 @@
             },
             {
               "mechanism": {
-                "handled": true,
-                "type": "generic"
+                "exception_id": 1,
+                "parent_id": 0,
+                "source": "cause",
+                "synthetic": false,
+                "type": "chained"
               },
               "module": null,
               "stacktrace": {
diff --git a/posthog/test/test_client.py b/posthog/test/test_client.py
index 531bbf1c9..1c86a0daa 100644
--- a/posthog/test/test_client.py
+++ b/posthog/test/test_client.py
@@ -573,6 +573,45 @@ def test_basic_capture_exception(self):
             self.assertEqual(capture_call[0][0], "$exception")
             self.assertEqual(capture_call[1]["distinct_id"], "distinct_id")
 
+    def test_reserved_exception_property_overrides_are_deprecated(self):
+        custom_exception_list = [{"type": "CustomError", "value": "custom"}]
+        properties = {
+            "$exception_list": custom_exception_list,
+            "$exception_level": "warning",
+            "$exception_source": "custom.source",
+            "$exception_issue_id": "legacy-issue-id",
+        }
+
+        with (
+            mock.patch.object(Client, "capture", return_value=None) as patch_capture,
+            self.assertWarnsRegex(
+                DeprecationWarning,
+                "Reserved exception properties.*next major version",
+            ),
+        ):
+            self.client.capture_exception(
+                Exception("test exception"), properties=properties
+            )
+
+        captured_properties = patch_capture.call_args.kwargs["properties"]
+        self.assertIs(captured_properties["$exception_list"], custom_exception_list)
+        self.assertEqual(captured_properties["$exception_level"], "warning")
+        self.assertEqual(captured_properties["$exception_source"], "custom.source")
+        self.assertEqual(captured_properties["$exception_issue_id"], "legacy-issue-id")
+
+    def test_reserved_exception_property_warning_cannot_drop_the_event(self):
+        with (
+            mock.patch.object(Client, "capture", return_value=None) as patch_capture,
+            warnings.catch_warnings(),
+        ):
+            warnings.simplefilter("error", DeprecationWarning)
+            self.client.capture_exception(
+                Exception("test exception"),
+                properties={"$exception_level": "warning"},
+            )
+
+        patch_capture.assert_called_once()
+
     @parameterized.expand(
         [
             (
diff --git a/posthog/test/test_exception_capture.py b/posthog/test/test_exception_capture.py
index ef83c433f..011677779 100644
--- a/posthog/test/test_exception_capture.py
+++ b/posthog/test/test_exception_capture.py
@@ -157,6 +157,16 @@ def test_exception_hooks_delegate_and_restore_previous_hooks(monkeypatch):
     capture.close()
 
     assert client.capture_exception.call_count == 2
+    assert client.capture_exception.call_args_list[0].kwargs["_capture_metadata"] == {
+        "level": "fatal",
+        "source": "python.sys_excepthook",
+        "mechanism": {"type": "onuncaughtexception", "handled": False},
+    }
+    assert client.capture_exception.call_args_list[1].kwargs["_capture_metadata"] == {
+        "level": "error",
+        "source": "python.threading_excepthook",
+        "mechanism": {"type": "onuncaughtexception", "handled": False},
+    }
     sys_hook.assert_called_once_with(*exc_info)
     thread_hook.assert_called_once_with(thread_args)
     assert sys.excepthook is sys_hook
@@ -248,7 +258,7 @@ def test_uncaught_thread_exception_preserves_default_diagnostic():
         from posthog.exception_capture import ExceptionCapture
 
         class Client:
-            def capture_exception(self, exception, distinct_id=None):
+            def capture_exception(self, exception, distinct_id=None, _capture_metadata=None):
                 print(f"captured:{exception[0].__name__}")
 
         capture = ExceptionCapture(Client())
@@ -306,10 +316,10 @@ def offline_post(url, **kwargs):
     assert b"ZeroDivisionError" in output
     assert b"LOL" in output
     assert b"DEBUG:posthog:[PostHog] data uploaded successfully" in output
-    assert (
-        b'"$exception_list": [{"mechanism": {"type": "generic", "handled": true}, "module": null, "type": "ZeroDivisionError", "value": "division by zero", "stacktrace": {"frames": [{"platform": "python", "filename": "app.py", "abs_path"'
-        in output
-    )
+    assert b'"$exception_level": "fatal"' in output
+    assert b'"$exception_source": "python.sys_excepthook"' in output
+    assert b'"type": "onuncaughtexception"' in output
+    assert b'"handled": false' in output
 
 
 class _RootError(Exception):
@@ -328,6 +338,10 @@ class _LeafTwo(Exception):
     pass
 
 
+class _ExceptionWithMetadata(Exception):
+    exceptions = 1
+
+
 def test_exception_list_canonical_order_explicit_cause():
     # Canonical ordering: $exception_list[0] is the caught/outermost exception
     # and the root cause is last. For `raise B from A`, B is caught and A is the
@@ -348,6 +362,19 @@ def test_exception_list_canonical_order_explicit_cause():
     assert types == ["_WrapperError", "_RootError"]
     assert exceptions[0]["value"] == "wrapper"
     assert exceptions[-1]["value"] == "root"
+    assert exceptions[0]["mechanism"] == {
+        "type": "generic",
+        "handled": True,
+        "synthetic": False,
+        "exception_id": 0,
+    }
+    assert exceptions[1]["mechanism"] == {
+        "type": "chained",
+        "source": "cause",
+        "synthetic": False,
+        "exception_id": 1,
+        "parent_id": 0,
+    }
 
 
 def test_exception_list_canonical_order_implicit_context():
@@ -369,6 +396,20 @@ def test_exception_list_canonical_order_implicit_context():
     assert types == ["_WrapperError", "_RootError"]
     assert exceptions[0]["value"] == "wrapper"
     assert exceptions[-1]["value"] == "root"
+    assert exceptions[1]["mechanism"]["source"] == "context"
+
+
+def test_ordinary_exception_does_not_treat_exceptions_attribute_as_group_members():
+    from posthog.exception_utils import exceptions_from_error_tuple
+
+    try:
+        raise _ExceptionWithMetadata("ordinary")
+    except _ExceptionWithMetadata:
+        exc_info = sys.exc_info()
+
+    exceptions = exceptions_from_error_tuple(exc_info)
+
+    assert [exception["type"] for exception in exceptions] == ["_ExceptionWithMetadata"]
 
 
 @pytest.mark.skipif(
@@ -392,3 +433,96 @@ def test_exception_list_canonical_order_exception_group():
     types = [e["type"] for e in exceptions]
     assert types[0] == "ExceptionGroup"
     assert types[1:] == ["_LeafOne", "_LeafTwo"]
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="ExceptionGroup requires Python 3.11+",
+)
+def test_exception_group_serializes_a_repeated_object_only_once():
+    from posthog.exception_utils import exceptions_from_error_tuple
+
+    shared = _LeafOne("shared")
+    try:
+        raise ExceptionGroup("group", [shared, shared])  # noqa: F821
+    except BaseException:
+        exc_info = sys.exc_info()
+
+    exceptions = exceptions_from_error_tuple(exc_info)
+
+    assert [exception["value"] for exception in exceptions] == [
+        "group",
+        "shared",
+    ]
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="ExceptionGroup requires Python 3.11+",
+)
+def test_exception_group_member_inspection_budget_counts_duplicates():
+    from posthog.exception_utils import exceptions_from_error_tuple
+
+    shared = _LeafOne("shared")
+    excluded = _LeafTwo("after-budget")
+    group = ExceptionGroup(  # noqa: F821 -- builtin on 3.11+
+        "group", [shared] * 1_000 + [excluded]
+    )
+
+    exceptions = exceptions_from_error_tuple((type(group), group, None))
+
+    assert [exception["value"] for exception in exceptions] == ["group", "shared"]
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="ExceptionGroup requires Python 3.11+",
+)
+def test_nested_exception_groups_share_member_inspection_budget():
+    from posthog.exception_utils import exceptions_from_error_tuple
+
+    shared = _LeafOne("shared")
+    inner_excluded = _LeafTwo("inner-after-budget")
+    outer_excluded = _LeafTwo("outer-after-budget")
+    inner = ExceptionGroup(  # noqa: F821 -- builtin on 3.11+
+        "inner", [shared] * 999 + [inner_excluded]
+    )
+    outer = ExceptionGroup(  # noqa: F821 -- builtin on 3.11+
+        "outer", [inner, outer_excluded]
+    )
+
+    exceptions = exceptions_from_error_tuple((type(outer), outer, None))
+
+    assert [exception["value"] for exception in exceptions] == [
+        "outer",
+        "inner",
+        "shared",
+    ]
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="ExceptionGroup requires Python 3.11+",
+)
+def test_last_inspected_group_member_retains_its_cause_chain():
+    from posthog.exception_utils import exceptions_from_error_tuple
+
+    shared = _LeafOne("shared")
+    cause = _RootError("cause")
+    final_member = _LeafTwo("last-inspected")
+    final_member.__cause__ = cause
+    excluded = _LeafTwo("after-budget")
+    group = ExceptionGroup(  # noqa: F821 -- builtin on 3.11+
+        "group", [shared] * 999 + [final_member, excluded]
+    )
+
+    exceptions = exceptions_from_error_tuple((type(group), group, None))
+
+    assert [exception["value"] for exception in exceptions] == [
+        "group",
+        "shared",
+        "last-inspected",
+        "cause",
+    ]
+    assert exceptions[-1]["mechanism"]["source"] == "cause"
+    assert exceptions[-1]["mechanism"]["parent_id"] == 2

From c4e6bdd7a89b9b7fb71f530e6d8e392c8fe02909 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:32:26 +0000
Subject: [PATCH 003/245] chore: Release v7.65.0 [skip ci]

---
 .sampo/changesets/canonical-exception-metadata.md | 5 -----
 openfeature-provider/CHANGELOG.md                 | 6 ++++++
 openfeature-provider/pyproject.toml               | 2 +-
 posthog/CHANGELOG.md                              | 6 ++++++
 posthog/version.py                                | 2 +-
 pyproject.toml                                    | 2 +-
 uv.lock                                           | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/canonical-exception-metadata.md

diff --git a/.sampo/changesets/canonical-exception-metadata.md b/.sampo/changesets/canonical-exception-metadata.md
deleted file mode 100644
index ea67a36e4..000000000
--- a/.sampo/changesets/canonical-exception-metadata.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Standardize exception capture metadata, including severity, capture source, typed integration metadata, mechanism semantics, bounded exception-group traversal, and deterministic cause linkage. Application overrides of reserved exception properties remain supported during a deprecation period, emit a warning, and will be removed in the next major version.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 747daf6b2..8c4f2ec3d 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.98 — 2026-10-08
+
+### Patch changes
+
+- Updated dependencies: posthog@7.65.0
+
 ## 0.1.97 — 2026-10-06
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 4987c5008..1338c0459 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.97"
+version = "0.1.98"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index bd760cde0..204a071ae 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.65.0 — 2026-10-08
+
+### Minor changes
+
+- [6d6cc3d](https://github.com/posthog/posthog-python/commit/6d6cc3dac989569f3c571308e4db9b9f6ecf7b36) Standardize exception capture metadata, including severity, capture source, typed integration metadata, mechanism semantics, bounded exception-group traversal, and deterministic cause linkage. Application overrides of reserved exception properties remain supported during a deprecation period, emit a warning, and will be removed in the next major version. — Thanks @hpouillot!
+
 ## 7.64.1 — 2026-10-06
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 570836b74..6d7e16a24 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.64.1"
+VERSION = "7.65.0"
diff --git a/pyproject.toml b/pyproject.toml
index 17052d31f..741b39bb9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.64.1"
+version = "7.65.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 60046d858..cb51bfae6 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2440,7 +2440,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.97"
+version = "0.1.98"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2770,7 +2770,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.64.1"
+version = "7.65.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 50efa658f160766aa5296a699393a7aad80b8e40 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:32:33 +0000
Subject: [PATCH 004/245] Update generated references

---
 .../posthog-python-references-7.65.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    4 +-
 2 files changed, 3550 insertions(+), 2 deletions(-)
 create mode 100644 references/posthog-python-references-7.65.0.json

diff --git a/references/posthog-python-references-7.65.0.json b/references/posthog-python-references-7.65.0.json
new file mode 100644
index 000000000..12adf4e4a
--- /dev/null
+++ b/references/posthog-python-references-7.65.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.65.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index a3912a89e..12adf4e4a 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.64.1",
+    "version": "7.65.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -2294,7 +2294,7 @@
           "params": [
             {
               "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
               "isOptional": false,
               "type": "BaseException"
             },

From 1c6a47ae235c127329c38db02cb6837a7f1c6434 Mon Sep 17 00:00:00 2001
From: Hugues Pouillot <hpouillot@gmail.com>
Date: Thu, 8 Oct 2026 16:07:26 +0200
Subject: [PATCH 005/245] feat(asgi): add error tracking middleware (#1037)

* feat(asgi): add error tracking middleware

* chore(asgi): type exception capture metadata

* fix(asgi): make tracing header trust explicit

* refactor(asgi): expose request properties terminology
---
 .sampo/changesets/asgi-error-tracking.md      |   5 +
 posthog/integrations/asgi.py                  | 249 +++++++++++++
 .../integrations/test_asgi_integration.py     | 333 ++++++++++++++++++
 references/public_api_snapshot.txt            |  10 +
 4 files changed, 597 insertions(+)
 create mode 100644 .sampo/changesets/asgi-error-tracking.md
 create mode 100644 posthog/integrations/asgi.py
 create mode 100644 posthog/test/integrations/test_asgi_integration.py

diff --git a/.sampo/changesets/asgi-error-tracking.md b/.sampo/changesets/asgi-error-tracking.md
new file mode 100644
index 000000000..b52661e71
--- /dev/null
+++ b/.sampo/changesets/asgi-error-tracking.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add framework-independent ASGI middleware for automatic request context and unhandled exception capture, supporting FastAPI, Starlette, Litestar, WebSockets, sync or async filters, additional request properties, and opt-in PostHog tracing headers without requiring a framework dependency.
diff --git a/posthog/integrations/asgi.py b/posthog/integrations/asgi.py
new file mode 100644
index 000000000..b00c18c87
--- /dev/null
+++ b/posthog/integrations/asgi.py
@@ -0,0 +1,249 @@
+"""Framework-independent ASGI request context and exception capture.
+
+The middleware speaks the ASGI protocol directly and has no dependency on an ASGI
+framework. It can therefore be used with FastAPI, Starlette, Litestar, or a raw
+ASGI application::
+
+    from fastapi import FastAPI
+    from posthog.integrations.asgi import PosthogASGIMiddleware
+
+    app = FastAPI()
+    app.add_middleware(PosthogASGIMiddleware)
+
+It can also wrap an application directly::
+
+    app = PosthogASGIMiddleware(app)
+
+Only HTTP and WebSocket connections are instrumented. Lifespan and custom ASGI
+scope types pass through unchanged.
+
+``X-PostHog-Distinct-ID`` and ``X-PostHog-Session-ID`` are client-controlled
+analytics context, not authentication. They are ignored by default. Set
+``trust_tracing_headers=True`` only when deliberately accepting browser analytics
+attribution or when a trusted upstream strips and replaces incoming values.
+"""
+
+import inspect
+import re
+from collections.abc import Awaitable, Callable, Mapping
+from typing import Any, Optional, Union, cast
+
+from .. import contexts
+from ..client import Client
+from ..exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+)
+
+_ASGIApp = Callable[
+    [
+        dict[str, Any],
+        Callable[[], Awaitable[dict[str, Any]]],
+        Callable[[dict[str, Any]], Awaitable[None]],
+    ],
+    Awaitable[None],
+]
+_RequestFilterResult = Union[bool, Awaitable[bool]]
+_RequestFilter = Callable[[dict[str, Any]], _RequestFilterResult]
+_ExtraPropertiesResult = Union[
+    Optional[Mapping[str, Any]], Awaitable[Optional[Mapping[str, Any]]]
+]
+_ExtraProperties = Callable[[dict[str, Any]], _ExtraPropertiesResult]
+
+_MAX_HEADER_LENGTH = 1000
+_MAX_PATH_LENGTH = 2048
+_CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f-\x9f]")
+_CAPTURE_METADATA: _ExceptionCaptureMetadata = {
+    "level": "error",
+    "source": "asgi.middleware",
+    "mechanism": {"type": "middleware", "handled": False},
+}
+
+
+def _sanitize_text(
+    value: object, max_length: int = _MAX_HEADER_LENGTH
+) -> Optional[str]:
+    if not isinstance(value, str) or not value:
+        return None
+    return _CONTROL_CHARS_RE.sub("", value).strip()[:max_length] or None
+
+
+def _decode_header(value: object) -> Optional[str]:
+    if not isinstance(value, bytes):
+        return None
+    return _sanitize_text(value.decode("latin-1"))
+
+
+def _headers_from_scope(scope: Mapping[str, Any]) -> dict[bytes, bytes]:
+    result: dict[bytes, bytes] = {}
+    headers = scope.get("headers", ())
+    if not isinstance(headers, (list, tuple)):
+        return result
+
+    for item in headers:
+        if (
+            isinstance(item, (list, tuple))
+            and len(item) == 2
+            and isinstance(item[0], bytes)
+            and isinstance(item[1], bytes)
+        ):
+            # Keep the first value. Tracing headers are singular, and joining arbitrary
+            # duplicate user input can create misleading identity values.
+            result.setdefault(item[0].lower(), item[1])
+    return result
+
+
+def _server_host(scope: Mapping[str, Any]) -> Optional[str]:
+    server = scope.get("server")
+    if not isinstance(server, (list, tuple)) or len(server) != 2:
+        return None
+
+    hostname, port = server
+    if not isinstance(hostname, str) or not isinstance(port, int):
+        return None
+
+    hostname = _sanitize_text(hostname)
+    if not hostname:
+        return None
+    if ":" in hostname and not hostname.startswith("["):
+        hostname = f"[{hostname}]"
+
+    scheme = scope.get("scheme")
+    default_port = (scheme == "http" and port == 80) or (
+        scheme == "https" and port == 443
+    )
+    return hostname if default_port else f"{hostname}:{port}"
+
+
+def _extract_properties(
+    scope: Mapping[str, Any], headers: Mapping[bytes, bytes]
+) -> dict[str, Any]:
+    properties: dict[str, Any] = {}
+
+    method = _sanitize_text(scope.get("method"), max_length=32)
+    if method:
+        properties["$request_method"] = method
+
+    path = _sanitize_text(scope.get("path"), max_length=_MAX_PATH_LENGTH)
+    if path:
+        properties["$request_path"] = path
+
+    user_agent = _decode_header(headers.get(b"user-agent"))
+    if user_agent:
+        properties["$user_agent"] = user_agent
+        properties["$raw_user_agent"] = user_agent
+
+    forwarded_for = _decode_header(headers.get(b"x-forwarded-for"))
+    if forwarded_for:
+        ip_address = _sanitize_text(forwarded_for.split(",", 1)[0])
+    else:
+        client = scope.get("client")
+        ip_address = (
+            _sanitize_text(client[0])
+            if isinstance(client, (list, tuple))
+            and client
+            and isinstance(client[0], str)
+            else None
+        )
+    if ip_address:
+        properties["$ip"] = ip_address
+
+    scheme = _sanitize_text(scope.get("scheme"), max_length=16)
+    host = _decode_header(headers.get(b"host")) or _server_host(scope)
+    if scheme and host and path:
+        # Deliberately omit query strings: they commonly contain secrets and
+        # high-cardinality values. The path remains available separately.
+        properties["$current_url"] = f"{scheme}://{host}{path}"
+
+    return properties
+
+
+async def _resolve_callback_result(value):
+    if inspect.isawaitable(value):
+        return await value
+    return value
+
+
+class PosthogASGIMiddleware:
+    """Add PostHog context and automatic exception capture to an ASGI app.
+
+    Args:
+        app: The downstream ASGI application.
+        client: Optional PostHog client. The global client is used by default.
+        capture_exceptions: Capture exceptions escaping the downstream app.
+        request_filter: Optional sync or async callback receiving the ASGI scope.
+            Returning ``False`` bypasses all instrumentation for that scope.
+        extra_properties: Optional sync or async callback receiving the ASGI scope and
+            returning additional event properties.
+        trust_tracing_headers: Use client-provided PostHog distinct and session ID
+            headers as analytics context. Disabled by default because these headers
+            are not authenticated. Enable only when deliberately accepting browser
+            attribution or when a trusted upstream replaces incoming values. Never
+            use these identifiers for authorization.
+    """
+
+    def __init__(
+        self,
+        app: _ASGIApp,
+        client: Optional[Client] = None,
+        capture_exceptions: bool = True,
+        request_filter: Optional[_RequestFilter] = None,
+        extra_properties: Optional[_ExtraProperties] = None,
+        trust_tracing_headers: bool = False,
+    ) -> None:
+        self.app = app
+        self.client = client
+        self.capture_exceptions = capture_exceptions
+        self.request_filter = request_filter
+        self.extra_properties = extra_properties
+        self.trust_tracing_headers = trust_tracing_headers
+
+    async def __call__(self, scope, receive, send) -> None:
+        if scope.get("type") not in {"http", "websocket"}:
+            await self.app(scope, receive, send)
+            return
+
+        if self.request_filter and not await _resolve_callback_result(
+            self.request_filter(scope)
+        ):
+            await self.app(scope, receive, send)
+            return
+
+        # Exception capture is explicit below so integration-specific mechanism
+        # metadata is preserved. The context itself must not capture a second time.
+        with contexts.new_context(capture_exceptions=False, client=self.client):
+            headers = _headers_from_scope(scope)
+            if self.trust_tracing_headers:
+                session_id = _decode_header(headers.get(b"x-posthog-session-id"))
+                if session_id:
+                    contexts.set_context_session(session_id)
+
+                distinct_id = _decode_header(headers.get(b"x-posthog-distinct-id"))
+                if distinct_id:
+                    contexts.identify_context(distinct_id)
+
+            properties = _extract_properties(scope, headers)
+            if self.extra_properties:
+                extra_properties = await _resolve_callback_result(
+                    self.extra_properties(scope)
+                )
+                if extra_properties:
+                    properties.update(extra_properties)
+            for key, value in properties.items():
+                contexts.tag(key, value)
+
+            try:
+                await self.app(scope, receive, send)
+            except Exception as exception:
+                if self.capture_exceptions:
+                    if self.client:
+                        _capture_exception_with_metadata(
+                            self.client, exception, _CAPTURE_METADATA
+                        )
+                    else:
+                        from .. import capture_exception
+
+                        cast(Any, capture_exception)(
+                            exception, _capture_metadata=_CAPTURE_METADATA
+                        )
+                raise
diff --git a/posthog/test/integrations/test_asgi_integration.py b/posthog/test/integrations/test_asgi_integration.py
new file mode 100644
index 000000000..5ddaecfa4
--- /dev/null
+++ b/posthog/test/integrations/test_asgi_integration.py
@@ -0,0 +1,333 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from posthog import contexts
+from posthog.client import Client
+from posthog.integrations.asgi import PosthogASGIMiddleware
+
+
+def http_scope(**overrides):
+    scope = {
+        "type": "http",
+        "asgi": {"version": "3.0"},
+        "http_version": "1.1",
+        "scheme": "https",
+        "method": "GET",
+        "path": "/api/items",
+        "raw_path": b"/api/items",
+        "query_string": b"token=secret",
+        "headers": [
+            (b"host", b"api.example.com"),
+            (b"user-agent", b"test-agent/1.0"),
+            (b"x-forwarded-for", b"203.0.113.5, 10.0.0.1"),
+            (b"x-posthog-session-id", b"session-123"),
+            (b"x-posthog-distinct-id", b"user-456"),
+        ],
+        "client": ("198.51.100.8", 1234),
+        "server": ("api.example.com", 443),
+    }
+    scope.update(overrides)
+    return scope
+
+
+async def noop_receive():
+    return {"type": "http.disconnect"}
+
+
+async def noop_send(message):
+    return None
+
+
+@pytest.mark.asyncio
+async def test_adds_request_properties_and_tracing_context_then_restores_parent():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["session_id"] = contexts.get_context_session_id()
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+        observed["properties"] = contexts.get_tags()
+        await send({"type": "http.response.start", "status": 204, "headers": []})
+        await send({"type": "http.response.body", "body": b""})
+
+    sent = []
+
+    async def send(message):
+        sent.append(message)
+
+    with contexts.new_context(fresh=True):
+        contexts.identify_context("parent-user")
+        contexts.tag("parent-property", "kept")
+        middleware = PosthogASGIMiddleware(app, trust_tracing_headers=True)
+        await middleware(http_scope(method="POST"), noop_receive, send)
+
+        assert contexts.get_context_distinct_id() == "parent-user"
+        assert contexts.get_context_session_id() is None
+        assert contexts.get_tags() == {"parent-property": "kept"}
+
+    assert observed["session_id"] == "session-123"
+    assert observed["distinct_id"] == "user-456"
+    assert observed["properties"] == {
+        "parent-property": "kept",
+        "$request_method": "POST",
+        "$request_path": "/api/items",
+        "$user_agent": "test-agent/1.0",
+        "$raw_user_agent": "test-agent/1.0",
+        "$ip": "203.0.113.5",
+        "$current_url": "https://api.example.com/api/items",
+    }
+    assert sent == [
+        {"type": "http.response.start", "status": 204, "headers": []},
+        {"type": "http.response.body", "body": b""},
+    ]
+    assert "secret" not in observed["properties"]["$current_url"]
+
+
+@pytest.mark.asyncio
+async def test_ignores_client_controlled_tracing_headers_by_default():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["session_id"] = contexts.get_context_session_id()
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+
+    await PosthogASGIMiddleware(app)(http_scope(), noop_receive, noop_send)
+
+    assert observed == {"session_id": None, "distinct_id": None}
+
+
+@pytest.mark.asyncio
+async def test_sanitizes_tracing_headers_and_uses_socket_ip_fallback():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["session_id"] = contexts.get_context_session_id()
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+        observed["properties"] = contexts.get_tags()
+
+    scope = http_scope(
+        headers=[
+            (b"host", b"example.com"),
+            (b"x-posthog-session-id", b"  session\n-123  "),
+            (b"x-posthog-distinct-id", b" user\t-456 "),
+        ]
+    )
+    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+        scope, noop_receive, noop_send
+    )
+
+    assert observed["session_id"] == "session-123"
+    assert observed["distinct_id"] == "user-456"
+    assert observed["properties"]["$ip"] == "198.51.100.8"
+
+
+@pytest.mark.asyncio
+async def test_malformed_and_duplicate_headers_are_handled_safely():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+
+    scope = http_scope(
+        headers=[
+            (b"x-posthog-distinct-id", b"first"),
+            (b"X-POSTHOG-DISTINCT-ID", b"second"),
+            ("not-bytes", "ignored"),
+            (b"incomplete",),
+        ]
+    )
+    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+        scope, noop_receive, noop_send
+    )
+
+    assert observed["distinct_id"] == "first"
+
+
+@pytest.mark.asyncio
+async def test_captures_exception_with_client_and_preserves_propagation():
+    client = Mock()
+    error = RuntimeError("application failed")
+
+    async def app(scope, receive, send):
+        assert contexts.get_tags()["$request_path"] == "/api/items"
+        raise error
+
+    middleware = PosthogASGIMiddleware(app, client=client)
+
+    with pytest.raises(RuntimeError, match="application failed") as raised:
+        await middleware(http_scope(), noop_receive, noop_send)
+
+    assert raised.value is error
+    client.capture_exception.assert_called_once_with(
+        error,
+        _capture_metadata={
+            "level": "error",
+            "source": "asgi.middleware",
+            "mechanism": {"type": "middleware", "handled": False},
+        },
+    )
+
+
+@pytest.mark.asyncio
+async def test_captured_event_uses_canonical_framework_boundary_metadata():
+    error = RuntimeError("application failed")
+
+    async def app(scope, receive, send):
+        raise error
+
+    client = Client("test-api-key", sync_mode=True)
+    try:
+        with patch.object(client, "capture", return_value="event-id") as capture:
+            with pytest.raises(RuntimeError, match="application failed"):
+                await PosthogASGIMiddleware(app, client=client)(
+                    http_scope(), noop_receive, noop_send
+                )
+
+        properties = capture.call_args.kwargs["properties"]
+        outermost = properties["$exception_list"][0]
+        assert properties["$exception_level"] == "error"
+        assert properties["$exception_source"] == "asgi.middleware"
+        assert outermost["mechanism"] == {
+            "type": "middleware",
+            "handled": False,
+            "exception_id": 0,
+            "synthetic": False,
+        }
+    finally:
+        client.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_captures_exception_with_global_client():
+    error = ValueError("bad request handler")
+
+    async def app(scope, receive, send):
+        raise error
+
+    with patch("posthog.capture_exception") as capture_exception:
+        with pytest.raises(ValueError, match="bad request handler"):
+            await PosthogASGIMiddleware(app)(http_scope(), noop_receive, noop_send)
+
+    capture_exception.assert_called_once_with(
+        error,
+        _capture_metadata={
+            "level": "error",
+            "source": "asgi.middleware",
+            "mechanism": {"type": "middleware", "handled": False},
+        },
+    )
+
+
+@pytest.mark.asyncio
+async def test_can_disable_exception_capture():
+    client = Mock()
+
+    async def app(scope, receive, send):
+        raise LookupError("not captured")
+
+    with pytest.raises(LookupError, match="not captured"):
+        await PosthogASGIMiddleware(app, client=client, capture_exceptions=False)(
+            http_scope(), noop_receive, noop_send
+        )
+
+    client.capture_exception.assert_not_called()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("async_filter", [False, True])
+async def test_request_filter_bypasses_all_instrumentation(async_filter):
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["session_id"] = contexts.get_context_session_id()
+        observed["properties"] = contexts.get_tags()
+
+    if async_filter:
+
+        async def request_filter(scope):
+            return False
+
+    else:
+
+        def request_filter(scope):
+            return False
+
+    with contexts.new_context(fresh=True):
+        contexts.tag("existing", True)
+        await PosthogASGIMiddleware(app, request_filter=request_filter)(
+            http_scope(), noop_receive, noop_send
+        )
+
+    assert observed == {"session_id": None, "properties": {"existing": True}}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("async_properties", [False, True])
+async def test_extra_properties_supports_sync_and_async_callbacks(async_properties):
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed.update(contexts.get_tags())
+
+    if async_properties:
+
+        async def extra_properties(scope):
+            return {"framework": "fastapi"}
+
+    else:
+
+        def extra_properties(scope):
+            return {"framework": "starlette"}
+
+    await PosthogASGIMiddleware(app, extra_properties=extra_properties)(
+        http_scope(), noop_receive, noop_send
+    )
+
+    assert observed["framework"] == ("fastapi" if async_properties else "starlette")
+
+
+@pytest.mark.asyncio
+async def test_websocket_scope_is_instrumented():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["session_id"] = contexts.get_context_session_id()
+        observed["path"] = contexts.get_tags()["$request_path"]
+
+    scope = http_scope(type="websocket", scheme="wss", method=None, path="/socket")
+    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+        scope, noop_receive, noop_send
+    )
+
+    assert observed == {"session_id": "session-123", "path": "/socket"}
+
+
+@pytest.mark.asyncio
+async def test_lifespan_scope_passes_through_without_context():
+    scope = {"type": "lifespan"}
+    observed = {}
+
+    async def app(received_scope, receive, send):
+        observed["scope"] = received_scope
+        observed["properties"] = contexts.get_tags()
+
+    with contexts.new_context(fresh=True):
+        contexts.tag("existing", "value")
+        await PosthogASGIMiddleware(app)(scope, noop_receive, noop_send)
+
+    assert observed == {"scope": scope, "properties": {"existing": "value"}}
+
+
+@pytest.mark.asyncio
+async def test_builds_url_from_server_when_host_header_is_absent():
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed.update(contexts.get_tags())
+
+    scope = http_scope(
+        headers=[], scheme="http", server=("2001:db8::1", 8080), path="/health"
+    )
+    await PosthogASGIMiddleware(app)(scope, noop_receive, noop_send)
+
+    assert observed["$current_url"] == "http://[2001:db8::1]:8080/health"
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 51ee00d9d..8c3300ec1 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -334,6 +334,8 @@ alias posthog.inner_set_code_variables_mask_url_credentials_context -> posthog.c
 alias posthog.inner_set_context_device_id -> posthog.contexts.set_context_device_id
 alias posthog.inner_set_context_session -> posthog.contexts.set_context_session
 alias posthog.inner_tag -> posthog.contexts.tag
+alias posthog.integrations.asgi.Client -> posthog.client.Client
+alias posthog.integrations.asgi.contexts -> posthog.contexts
 alias posthog.integrations.django.Client -> posthog.client.Client
 alias posthog.integrations.django.contexts -> posthog.contexts
 alias posthog.mcp.CaptureEventData -> posthog.mcp.types.CaptureEventData
@@ -861,6 +863,12 @@ attribute posthog.flag_definition_cache.FlagDefinitionCacheData.property_matchin
 attribute posthog.flag_definition_cache_provider = None
 attribute posthog.host = None
 attribute posthog.in_app_modules = None
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.app = app
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.capture_exceptions = capture_exceptions
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.client = client
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.extra_properties = extra_properties
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.request_filter = request_filter
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers = trust_tracing_headers
 attribute posthog.integrations.celery.PosthogCeleryIntegration.capture_exceptions = capture_exceptions
 attribute posthog.integrations.celery.PosthogCeleryIntegration.capture_task_lifecycle_events = capture_task_lifecycle_events
 attribute posthog.integrations.celery.PosthogCeleryIntegration.client = client
@@ -1197,6 +1205,7 @@ class posthog.feature_flags.InconclusiveMatchError
 class posthog.feature_flags.RequiresServerEvaluation 
 class posthog.flag_definition_cache.FlagDefinitionCacheData 
 class posthog.flag_definition_cache.FlagDefinitionCacheProvider 
+class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: bool = True, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: bool = False)
 class posthog.integrations.celery.PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
 class posthog.integrations.django.PosthogContextMiddleware(get_response)
 class posthog.mcp.McpAnalytics(key: Any)
@@ -1774,6 +1783,7 @@ module posthog.feature_flag_evaluations
 module posthog.feature_flags
 module posthog.flag_definition_cache
 module posthog.integrations
+module posthog.integrations.asgi
 module posthog.integrations.celery
 module posthog.integrations.django
 module posthog.mcp

From 127009dc394af6638a3ea8a88bdb0dcae46db0c3 Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Thu, 8 Oct 2026 17:11:25 +0300
Subject: [PATCH 006/245] feat(mcp): resolve fresh low-level tool ownership
 (#1009)

* feat(mcp): resolve fresh low-level tool ownership

Add resolve_original_tool for raw MCP SDK 1.x and 2.x servers. Prefer ownership learned from a served listing and keep unknown ownership fail-open.

Generated-By: PostHog Desktop
Task-Id: db1a8a08-fe03-43b6-9e49-705e8b1f375e

* fix(mcp): preserve listed argument ownership

Generated-By: PostHog Desktop
Task-Id: db1a8a08-fe03-43b6-9e49-705e8b1f375e

* fix(mcp): preserve arguments for unknown schemas

Generated-By: PostHog Desktop
Task-Id: db1a8a08-fe03-43b6-9e49-705e8b1f375e

* fix(mcp): preserve low-level tool schemas

Generated-By: PostHog Desktop
Task-Id: db1a8a08-fe03-43b6-9e49-705e8b1f375e
---
 .../changesets/mcp-lowlevel-tool-ownership.md |   7 +
 posthog/mcp/_argument_ownership.py            |  98 +++++++
 posthog/mcp/_context_parameters.py            |  14 +-
 posthog/mcp/_conversation_id.py               |   6 +-
 posthog/mcp/_instrument_lowlevel.py           |  83 ++++--
 posthog/mcp/_instrument_v2.py                 |  33 ++-
 posthog/mcp/_instrumentation.py               |  48 +++-
 posthog/mcp/_intent.py                        |   3 +
 posthog/mcp/_internal.py                      |  10 +-
 posthog/mcp/_sanitization.py                  |  27 +-
 posthog/mcp/types.py                          |   4 +
 posthog/test/mcp/test_features_m4.py          |   4 +-
 posthog/test/mcp/test_lowlevel.py             | 256 +++++++++++++++++
 posthog/test/mcp/test_types.py                |  15 +
 posthog/test/mcp/test_v2_lowlevel.py          | 266 ++++++++++++++++++
 posthog/test/mcp/test_virtual_tools.py        |  13 +-
 references/public_api_snapshot.txt            |   3 +-
 17 files changed, 827 insertions(+), 63 deletions(-)
 create mode 100644 .sampo/changesets/mcp-lowlevel-tool-ownership.md
 create mode 100644 posthog/mcp/_argument_ownership.py

diff --git a/.sampo/changesets/mcp-lowlevel-tool-ownership.md b/.sampo/changesets/mcp-lowlevel-tool-ownership.md
new file mode 100644
index 000000000..ec0a54a2c
--- /dev/null
+++ b/.sampo/changesets/mcp-lowlevel-tool-ownership.md
@@ -0,0 +1,7 @@
+---
+pypi/posthog: minor
+---
+
+Add `resolve_original_tool` for low-level MCP servers. Fresh server instances can now remove PostHog-owned arguments before strict tool validation.
+
+Raw low-level servers also remove PostHog-owned arguments after `tools/list`. A tool-owned `context` remains tool data.
diff --git a/posthog/mcp/_argument_ownership.py b/posthog/mcp/_argument_ownership.py
new file mode 100644
index 000000000..3ade16fec
--- /dev/null
+++ b/posthog/mcp/_argument_ownership.py
@@ -0,0 +1,98 @@
+"""Resolve ownership of arguments that PostHog adds to MCP tool schemas."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Mapping
+from typing import Any, Dict, FrozenSet, Optional, Tuple
+
+from ._context_parameters import is_context_enabled, schema_has_param
+from ._model_parameters import is_capture_model_enabled
+from .logger import log
+
+_COMPLEX_SCHEMA_KEYS = ("$ref", "oneOf", "allOf", "anyOf")
+
+
+def analytics_owned_parameters(
+    options: Any,
+    input_schema: Any,
+) -> FrozenSet[str]:
+    """Return the enabled arguments that PostHog can add to this schema."""
+    enabled = set()
+    if is_context_enabled(options.context):
+        enabled.add("context")
+    if options.enable_conversation_id:
+        enabled.add("conversation_id")
+    if is_capture_model_enabled(options.capture_model):
+        enabled.add("llm_model")
+
+    if isinstance(input_schema, dict) and any(
+        input_schema.get(key) for key in _COMPLEX_SCHEMA_KEYS
+    ):
+        return frozenset()
+    return frozenset(
+        name for name in enabled if not schema_has_param(input_schema, name)
+    )
+
+
+def cache_listed_tool_ownership(
+    data: Any, tool: Any, *, schema_attribute: str
+) -> FrozenSet[str]:
+    """Cache ownership from the host schema before PostHog changes it."""
+    name = getattr(tool, "name", None)
+    if not isinstance(name, str):
+        return frozenset()
+    schema = getattr(tool, schema_attribute, None)
+    ownership = analytics_owned_parameters(data.options, schema)
+    data.tool_analytics_parameter_ownership[name] = ownership
+    if isinstance(schema, dict):
+        data.tool_input_schemas[name] = schema
+    else:
+        data.tool_input_schemas.pop(name, None)
+    return ownership
+
+
+async def resolve_lowlevel_tool_ownership(
+    data: Any, name: str
+) -> Tuple[Optional[FrozenSet[str]], Optional[Dict[str, Any]]]:
+    """Resolve one raw tool. A served listing on this instance has priority."""
+    if name in data.tool_analytics_parameter_ownership:
+        return (
+            data.tool_analytics_parameter_ownership[name],
+            data.tool_input_schemas.get(name),
+        )
+
+    resolver = data.options.resolve_original_tool
+    if resolver is None:
+        return None, None
+
+    try:
+        descriptor = resolver(name)
+        if inspect.isawaitable(descriptor):
+            descriptor = await descriptor
+        if descriptor is None:
+            return None, None
+        schema = _descriptor_input_schema(descriptor)
+        if not isinstance(schema, dict):
+            log(
+                f"Warning: resolve_original_tool failed for tool {name!r}: "
+                "resolver returned no usable input schema"
+            )
+            return None, None
+        return analytics_owned_parameters(data.options, schema), schema
+    except Exception as error:  # noqa: BLE001 - analytics must not break dispatch
+        log(f"Warning: resolve_original_tool failed for tool {name!r}: {error}")
+        return None, None
+
+
+def _descriptor_input_schema(descriptor: Any) -> Any:
+    """Read MCP 1.x, MCP 2.x, and dictionary tool descriptors."""
+    if isinstance(descriptor, Mapping):
+        if "inputSchema" in descriptor:
+            return descriptor["inputSchema"]
+        return descriptor.get("input_schema")
+
+    schema = getattr(descriptor, "input_schema", None)
+    if schema is not None:
+        return schema
+    return getattr(descriptor, "inputSchema", None)
diff --git a/posthog/mcp/_context_parameters.py b/posthog/mcp/_context_parameters.py
index 015663d6b..943d13764 100644
--- a/posthog/mcp/_context_parameters.py
+++ b/posthog/mcp/_context_parameters.py
@@ -48,10 +48,11 @@ def add_context_parameter_to_schema(
     """Return a new JSON Schema dict with a ``context`` string property added.
 
     Returns the input unchanged (logging a warning) for schemas that already
-    define ``context`` or use ``oneOf``/``allOf``/``anyOf``. ``required`` controls
-    whether ``context`` is added to the schema's ``required`` list — pass ``False``
-    where the advertised schema is also used to validate inbound calls (the
-    low-level server), so a call omitting ``context`` is not rejected."""
+    define ``context`` or use ``$ref``/``oneOf``/``allOf``/``anyOf``. ``required``
+    controls whether ``context`` is added to the schema's ``required`` list —
+    pass ``False`` where the advertised schema is also used to validate inbound
+    calls (the low-level server), so a call omitting ``context`` is not rejected.
+    """
     schema = input_schema
 
     if (
@@ -64,9 +65,10 @@ def add_context_parameter_to_schema(
         )
         return schema
 
-    if schema and (schema.get("oneOf") or schema.get("allOf") or schema.get("anyOf")):
+    if schema and any(schema.get(key) for key in ("$ref", "oneOf", "allOf", "anyOf")):
         log(
-            f'WARN: Tool "{tool_name}" has complex schema (oneOf/allOf/anyOf). Skipping context injection.'
+            f'WARN: Tool "{tool_name}" has complex schema '
+            "($ref/oneOf/allOf/anyOf). Skipping context injection."
         )
         return schema
 
diff --git a/posthog/mcp/_conversation_id.py b/posthog/mcp/_conversation_id.py
index 506f878ce..d3c774516 100644
--- a/posthog/mcp/_conversation_id.py
+++ b/posthog/mcp/_conversation_id.py
@@ -35,7 +35,9 @@ def add_conversation_id_to_schema(
     input_schema: Optional[Dict[str, Any]], tool_name: str = "unknown"
 ) -> Optional[Dict[str, Any]]:
     """Return a new JSON Schema with an optional ``conversation_id`` string property.
-    Skips schemas that already define it or use ``oneOf``/``allOf``/``anyOf``."""
+    Skips schemas that already define it or use
+    ``$ref``/``oneOf``/``allOf``/``anyOf``.
+    """
     schema = input_schema
     if (
         schema
@@ -48,7 +50,7 @@ def add_conversation_id_to_schema(
             f"WARN: Tool \"{tool_name}\" already has '{CONVERSATION_ID_PARAM_NAME}'. Skipping injection."
         )
         return schema
-    if schema and (schema.get("oneOf") or schema.get("allOf") or schema.get("anyOf")):
+    if schema and any(schema.get(key) for key in ("$ref", "oneOf", "allOf", "anyOf")):
         log(
             f'WARN: Tool "{tool_name}" has complex schema. Skipping conversation_id injection.'
         )
diff --git a/posthog/mcp/_instrument_lowlevel.py b/posthog/mcp/_instrument_lowlevel.py
index f8e476283..00bd4ef4d 100644
--- a/posthog/mcp/_instrument_lowlevel.py
+++ b/posthog/mcp/_instrument_lowlevel.py
@@ -22,6 +22,10 @@
 
 import mcp.types as mcp_types
 
+from ._argument_ownership import (
+    cache_listed_tool_ownership,
+    resolve_lowlevel_tool_ownership,
+)
 from ._context_parameters import is_context_enabled, schema_has_param
 from ._conversation_id import build_prompt_back
 from ._event_types import MCPAnalyticsEventType
@@ -29,6 +33,7 @@
     advertised_tool_names,
     apply_virtual_tool_injection,
     collect_listed_tools,
+    copy_tools_list_result,
     extract_tools,
     is_first_listing_page,
     mutate_tool_schema,
@@ -54,9 +59,11 @@
 
 
 def instrument_low_level(server: Any, data: MCPAnalyticsData) -> None:
-    """Instrument a raw ``mcp.server.Server``. ``context`` is injected as an
-    optional schema property and NOT stripped — that schema is also the call's
-    validation schema, and a typical ``(name, arguments)`` handler ignores extra keys."""
+    """Instrument a raw ``mcp.server.Server``.
+
+    The adapter removes arguments that a listing or resolver proves PostHog
+    owns. Unknown arguments pass through unchanged.
+    """
     data.server_name = getattr(server, "name", None)
     data.server_version = getattr(server, "version", None)
     _wrap_call_tool(server, data, strip_injected=False)
@@ -186,11 +193,21 @@ def _wrap_call_tool(
     async def handler(req: Any) -> Any:
         name = req.params.name
         arguments = dict(req.params.arguments or {})
-        strip, model_ours, input_schema = (
-            await _standalone_ownership(data, high_level, name, req.params.meta)
-            if strip_injected
-            else (set(), data.tool_model_parameter_injected.get(name), None)
-        )
+        parameter_ownership = None
+        if strip_injected:
+            strip, model_ours, input_schema = await _standalone_ownership(
+                data, high_level, name, req.params.meta
+            )
+        else:
+            parameter_ownership, input_schema = await resolve_lowlevel_tool_ownership(
+                data, name
+            )
+            strip = set(parameter_ownership or ())
+            model_ours = (
+                "llm_model" in parameter_ownership
+                if parameter_ownership is not None
+                else data.tool_model_parameter_injected.get(name)
+            )
         client_name, client_version = _client_info(server)
         protocol_version = _protocol_version(server)
         mcp_session_id = _mcp_session_id(server)
@@ -213,6 +230,7 @@ async def handler(req: Any) -> Any:
             protocol_version=protocol_version,
             extra={"session_id": mcp_session_id, "ctx": _request_context(server)},
             input_schema=input_schema,
+            analytics_owned_parameters=parameter_ownership,
         )
 
         if lifecycle.is_missing_capability and (
@@ -327,6 +345,7 @@ async def handler(req: Any) -> Any:
 
 
 def _inject_tool_schemas(
+    server: Any,
     data: MCPAnalyticsData,
     tools: list,
     *,
@@ -345,6 +364,7 @@ def _inject_tool_schemas(
     verdicts: Dict[str, bool] = {}
     for tool in tools:
         schema = getattr(tool, "inputSchema", None)
+        cache_listed_tool_ownership(data, tool, schema_attribute="inputSchema")
         mutate_tool_schema(
             data,
             tool,
@@ -363,6 +383,11 @@ def _inject_tool_schemas(
             # Which one dispatches is unknown, so the strip fails closed.
             data.tool_model_parameter_injected[tool.name] = False
 
+    cache = getattr(server, "_tool_cache", None)
+    if isinstance(cache, dict):
+        for tool in tools:
+            cache[tool.name] = tool
+
 
 def _wrap_list_tools(
     server: Any,
@@ -404,16 +429,18 @@ async def probe_raw_tool_names(_ctx: Any = None) -> Optional[Set[str]]:
                     "registering your handlers."
                 )
             return None
-        result = await original(mcp_types.ListToolsRequest(method="tools/list"))
+        result = copy_tools_list_result(
+            await original(mcp_types.ListToolsRequest(method="tools/list"))
+        )
         tools = extract_tools(result)
-        # `original` is usually the SDK's own list_tools decorator, which rebuilds
-        # `Server._tool_cache` from these un-injected schemas every time it runs.
-        # That cache is what the SDK validates real tool arguments against, so
-        # without re-injecting here the next real call is rejected for sending the
-        # `context` we advertised. Same reason the `req is None` branch below
-        # injects.
+        # Resolve ownership from the host listing. Apply injection only to the
+        # copy so a shared host descriptor remains original.
         _inject_tool_schemas(
-            data, tools, context_required=context_required, high_level=high_level
+            server,
+            data,
+            tools,
+            context_required=context_required,
+            high_level=high_level,
         )
         return advertised_tool_names(tools)
 
@@ -421,17 +448,17 @@ async def probe_raw_tool_names(_ctx: Any = None) -> Optional[Set[str]]:
 
     async def handler(req: Any) -> Any:
         # The server calls the handler with None to populate its tool cache.
-        # Skip analytics there — but still inject, because that cache is the
-        # schema the SDK validates calls against. This adapter advertises
-        # `context`/`conversation_id` without stripping them, so a cache built
-        # from un-injected schemas rejects the very arguments we told the agent
-        # to send ("Additional properties are not allowed") on any tool with
-        # `additionalProperties: false`.
+        # Skip analytics there, but return the same injected schema as a client
+        # listing.
         if req is None:
-            result = await original(req)
+            result = copy_tools_list_result(await original(req))
             tools = extract_tools(result)
             _inject_tool_schemas(
-                data, tools, context_required=context_required, high_level=high_level
+                server,
+                data,
+                tools,
+                context_required=context_required,
+                high_level=high_level,
             )
             return result
 
@@ -464,7 +491,7 @@ async def handler(req: Any) -> Any:
 
         start = time.monotonic()
         try:
-            result = await original(req)
+            result = copy_tools_list_result(await original(req))
         except Exception as error:
             await lifecycle.record_error(error, (time.monotonic() - start) * 1000)
             raise
@@ -481,7 +508,11 @@ async def handler(req: Any) -> Any:
         )
 
         _inject_tool_schemas(
-            data, tools, context_required=context_required, high_level=high_level
+            server,
+            data,
+            tools,
+            context_required=context_required,
+            high_level=high_level,
         )
 
         result = apply_virtual_tool_injection(
diff --git a/posthog/mcp/_instrument_v2.py b/posthog/mcp/_instrument_v2.py
index 8191eedc8..843f2d032 100644
--- a/posthog/mcp/_instrument_v2.py
+++ b/posthog/mcp/_instrument_v2.py
@@ -37,6 +37,10 @@
 
 import mcp.types as mcp_types
 
+from ._argument_ownership import (
+    cache_listed_tool_ownership,
+    resolve_lowlevel_tool_ownership,
+)
 from ._context_parameters import is_context_enabled, schema_has_param
 from ._conversation_id import build_prompt_back
 from ._event_types import MCPAnalyticsEventType
@@ -44,6 +48,7 @@
     advertised_tool_names,
     apply_virtual_tool_injection,
     collect_listed_tools,
+    copy_tools_list_result,
     is_first_listing_page,
     mutate_tool_schema,
     params_to_request_dict,
@@ -503,21 +508,30 @@ async def handler(ctx: Any, params: Any) -> Any:
         # reads the self-reported model anyway; only a listing that proved the
         # application owns `llm_model` stops it (posthog-js ADR-0011).
         analytics_owns_model = data.tool_model_parameter_injected.get(name) is not False
-        input_schema = None
         standalone = data.standalone_fastmcp() if data.standalone_fastmcp else None
+        parameter_ownership = None
+        input_schema = None
         if standalone is not None:
             version = _requested_tool_version(ctx)
             injected, input_schema = await _standalone_injected_parameters(
                 standalone, data, name, version
             )
             if injected is not None:
+                parameter_ownership = injected
                 analytics_owns_model = "llm_model" in injected
-                call_arguments = {
-                    key: value
-                    for key, value in arguments.items()
-                    if key not in injected
-                }
-                params = params.model_copy(update={"arguments": call_arguments})
+        else:
+            parameter_ownership, input_schema = await resolve_lowlevel_tool_ownership(
+                data, name
+            )
+            if parameter_ownership is not None:
+                analytics_owns_model = "llm_model" in parameter_ownership
+        if parameter_ownership is not None:
+            call_arguments = {
+                key: value
+                for key, value in arguments.items()
+                if key not in parameter_ownership
+            }
+            params = params.model_copy(update={"arguments": call_arguments})
         token, client_name, client_version, protocol_version, mcp_session_id = (
             _resolve_ctx(ctx)
         )
@@ -534,6 +548,7 @@ async def handler(ctx: Any, params: Any) -> Any:
             protocol_version=protocol_version,
             extra={"session_id": mcp_session_id, "ctx": ctx},
             input_schema=input_schema,
+            analytics_owned_parameters=parameter_ownership,
         )
 
         # No tool registry on a raw low-level server, so ownership is settled
@@ -700,7 +715,7 @@ async def handler(ctx: Any, params: Any) -> Any:
 
         start = time.monotonic()
         try:
-            result = await original(ctx, params)
+            result = copy_tools_list_result(await original(ctx, params))
         except Exception as error:
             await lifecycle.record_error(error, (time.monotonic() - start) * 1000)
             raise
@@ -715,6 +730,7 @@ async def handler(ctx: Any, params: Any) -> Any:
 
         for tool in tools:
             schema = getattr(tool, "input_schema", None)
+            cache_listed_tool_ownership(data, tool, schema_attribute="input_schema")
             owns_context = (
                 _tool_owns_param_v2(high_level, tool.name, "context")
                 if high_level is not None
@@ -728,7 +744,6 @@ async def handler(ctx: Any, params: Any) -> Any:
                 context_required=context_required,
                 is_sdk_virtual_tool=False,
             )
-
         result = apply_virtual_tool_injection(
             result, injection, names, data, schema_field="input_schema"
         )
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index 5a82fa035..167969069 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -10,11 +10,12 @@
 
 import asyncio
 import concurrent.futures
+import copy
 import os
 import threading
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Literal, Optional, Set
+from typing import Any, Dict, FrozenSet, List, Literal, Optional, Set
 
 from ._capture import capture_event
 from ._context_parameters import (
@@ -434,6 +435,7 @@ class ToolCallLifecycle:
     arguments: Optional[Dict[str, Any]]
     request_meta: Optional[Dict[str, Any]]
     allow_self_reported_model: bool
+    analytics_owned_parameters: Optional[FrozenSet[str]]
     request: Dict[str, Any]
     extra: Dict[str, Any]
     mcp_session_id: Optional[str]
@@ -541,6 +543,7 @@ async def record_error(self, error: Any, duration_ms: float) -> None:
             arguments=self.arguments,
             request_meta=self.request_meta,
             allow_self_reported_model=self.allow_self_reported_model,
+            analytics_owned_parameters=self.analytics_owned_parameters,
             error=error,
             duration_ms=duration_ms,
             client_name=self.client_name,
@@ -563,6 +566,7 @@ async def record_result(
             arguments=self.arguments,
             request_meta=self.request_meta,
             allow_self_reported_model=self.allow_self_reported_model,
+            analytics_owned_parameters=self.analytics_owned_parameters,
             result=result,
             duration_ms=duration_ms,
             client_name=self.client_name,
@@ -588,6 +592,7 @@ def start_tool_call_lifecycle(
     protocol_version: Optional[str],
     extra: Dict[str, Any],
     input_schema: Any = None,
+    analytics_owned_parameters: Optional[FrozenSet[str]] = None,
 ) -> ToolCallLifecycle:
     """Resolve adapter-independent policy for a tool call without dispatching it."""
     enabled = enabled_virtual_tool_names(data)
@@ -597,7 +602,12 @@ def start_tool_call_lifecycle(
     # running the host's `on_feedback` handler read the configured options.
     feedback_options = resolve_collect_feedback_options(data.options.collect_feedback)
     conversation_id, minted = resolve_conversation_id(
-        data.options.enable_conversation_id, arguments
+        data.options.enable_conversation_id
+        and (
+            analytics_owned_parameters is None
+            or "conversation_id" in analytics_owned_parameters
+        ),
+        arguments,
     )
     # A carried session stays stable until the agent supplies its own handle.
     has_carried_session = token is not None or bool(mcp_session_id)
@@ -609,6 +619,7 @@ def start_tool_call_lifecycle(
         arguments=arguments,
         request_meta=request_meta,
         allow_self_reported_model=allow_self_reported_model,
+        analytics_owned_parameters=analytics_owned_parameters,
         request=build_tool_call_request(name, arguments),
         extra=extra,
         mcp_session_id=mcp_session_id,
@@ -642,6 +653,7 @@ async def record_tool_call(
     conversation_id: Optional[str] = None,
     extra: Optional[Dict[str, Any]] = None,
     input_schema: Any = None,
+    analytics_owned_parameters: Optional[FrozenSet[str]] = None,
 ) -> None:
     # Analytics must never change what the tool returns or raises: any failure
     # building/publishing the event is logged and swallowed here.
@@ -654,7 +666,13 @@ async def record_tool_call(
             "tool_description": data.tool_descriptions.get(name),
             "tool_category": data.tool_categories.get(name),
             "parameters": build_captured_mcp_parameters(
-                request, strip_llm_model=allow_self_reported_model
+                request,
+                strip_llm_model=allow_self_reported_model,
+                strip_argument_names=(
+                    set(analytics_owned_parameters)
+                    if analytics_owned_parameters is not None
+                    else None
+                ),
             ),
             "duration": duration_ms,
             "client_name": client_name,
@@ -663,7 +681,18 @@ async def record_tool_call(
             "conversation_id": conversation_id,
             "is_error": False,
         }
-        set_event_intent(event, await resolve_tool_call_intent(data, request, extra))
+        set_event_intent(
+            event,
+            await resolve_tool_call_intent(
+                data,
+                request,
+                extra,
+                allow_context_argument=(
+                    analytics_owned_parameters is None
+                    or "context" in analytics_owned_parameters
+                ),
+            ),
+        )
         if is_capture_model_enabled(data.options.capture_model):
             model, source = resolve_model(
                 request_meta,
@@ -714,6 +743,17 @@ def extract_tools(result: Any) -> list:
     return list(getattr(root, "tools", []) or [])
 
 
+def copy_tools_list_result(result: Any) -> Any:
+    """Copy a tool listing before schema injection changes its descriptors."""
+    try:
+        return result.model_copy(deep=True)
+    except Exception:  # noqa: BLE001 - analytics must not break a listing
+        try:
+            return copy.deepcopy(result)
+        except Exception:  # noqa: BLE001
+            return result
+
+
 def tools_list_envelope(result: Any) -> Optional[Dict[str, Any]]:
     """The ``tools/list`` result minus its tools, or None when nothing else is set.
 
diff --git a/posthog/mcp/_intent.py b/posthog/mcp/_intent.py
index 076a3e1d8..e8a3b3165 100644
--- a/posthog/mcp/_intent.py
+++ b/posthog/mcp/_intent.py
@@ -55,6 +55,8 @@ async def resolve_tool_call_intent(
     data: MCPAnalyticsData,
     request: Dict[str, Any],
     extra: Optional[Dict[str, Any]] = None,
+    *,
+    allow_context_argument: bool = True,
 ) -> Optional[ResolvedIntent]:
     from ._instrumentation import (
         VIRTUAL_TOOL_MISSING_CAPABILITY,
@@ -71,6 +73,7 @@ async def resolve_tool_call_intent(
     missing_name = enabled_virtual_tool_names(data).get(VIRTUAL_TOOL_MISSING_CAPABILITY)
     if (
         is_context_enabled(data.options.context)
+        and allow_context_argument
         and (missing_name is None or name != missing_name)
         and context_argument
     ):
diff --git a/posthog/mcp/_internal.py b/posthog/mcp/_internal.py
index e1cdecef0..12bc83d28 100644
--- a/posthog/mcp/_internal.py
+++ b/posthog/mcp/_internal.py
@@ -17,7 +17,7 @@
 from collections import OrderedDict
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, Awaitable, Callable, Dict, Optional, Set, Tuple
+from typing import Any, Awaitable, Callable, Dict, FrozenSet, Optional, Set, Tuple
 
 from .logger import log
 from ._sink import McpEventSink
@@ -91,6 +91,14 @@ class MCPAnalyticsData:
     # True only when PostHog added llm_model to this tool's advertised schema.
     # Missing/False fails closed so an application-owned field is never read or stripped.
     tool_model_parameter_injected: Dict[str, bool] = field(default_factory=dict)
+    # Ownership learned from tools/list on this instance has priority over the
+    # low-level resolver callback.
+    tool_analytics_parameter_ownership: Dict[str, FrozenSet[str]] = field(
+        default_factory=dict
+    )
+    # Original schemas used to resolve ownership. They also identify safe input
+    # names without recording argument values.
+    tool_input_schemas: Dict[str, Dict[str, Any]] = field(default_factory=dict)
     # Which tools got `_mcp_instructions` declared on their advertised output
     # schema at tools/list. Only those may be mirrored into on a call — writing
     # an undeclared key fails the customer's whole result under
diff --git a/posthog/mcp/_sanitization.py b/posthog/mcp/_sanitization.py
index 0600ab69a..b14f4796d 100644
--- a/posthog/mcp/_sanitization.py
+++ b/posthog/mcp/_sanitization.py
@@ -11,7 +11,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 from urllib.parse import SplitResult, parse_qsl, urlencode, urlsplit, urlunsplit
 
 # SDK-injected arguments stripped from captured $mcp_parameters (they surface as
@@ -740,7 +740,10 @@ def _sanitize_resource_block(block: Dict[str, Any]) -> Any:
 
 
 def build_captured_mcp_parameters(
-    request: Any, *, strip_llm_model: bool = False
+    request: Any,
+    *,
+    strip_llm_model: bool = False,
+    strip_argument_names: Optional[Set[str]] = None,
 ) -> Dict[str, Any]:
     """Build the sanitized ``$mcp_parameters`` payload from a request, stripping
     the injected ``context`` argument before logging."""
@@ -752,35 +755,45 @@ def build_captured_mcp_parameters(
         if key in request:
             captured_request[key] = sanitize_captured_value(request[key])
 
+    names_to_strip = strip_argument_names
+    if names_to_strip is None:
+        names_to_strip = set(_INJECTED_ARGUMENT_NAMES)
+        if strip_llm_model:
+            names_to_strip.add("llm_model")
+
     if "params" in request:
         captured_request["params"] = _build_captured_mcp_params(
-            request["params"], strip_llm_model=strip_llm_model
+            request["params"], strip_argument_names=names_to_strip
         )
 
     return {"request": captured_request}
 
 
-def _build_captured_mcp_params(params: Any, *, strip_llm_model: bool) -> Any:
+def _build_captured_mcp_params(params: Any, *, strip_argument_names: Set[str]) -> Any:
     if not _is_record(params):
         return sanitize_captured_value(params)
 
     captured: Dict[str, Any] = {}
     for key, value in params.items():
         captured[key] = (
-            _build_captured_mcp_arguments(value, strip_llm_model=strip_llm_model)
+            _build_captured_mcp_arguments(
+                value, strip_argument_names=strip_argument_names
+            )
             if key == "arguments"
             else sanitize_captured_value(value)
         )
     return captured
 
 
-def _build_captured_mcp_arguments(arguments: Any, *, strip_llm_model: bool) -> Any:
+def _build_captured_mcp_arguments(
+    arguments: Any, *, strip_argument_names: Set[str]
+) -> Any:
     if not _is_record(arguments):
         return sanitize_captured_value(arguments)
 
     captured: Dict[str, Any] = {}
     for key, value in arguments.items():
-        if key in _INJECTED_ARGUMENT_NAMES or (strip_llm_model and key == "llm_model"):
+        if key in strip_argument_names:
             continue
         captured[key] = sanitize_captured_value(value)
     return captured
diff --git a/posthog/mcp/types.py b/posthog/mcp/types.py
index f65ae0d26..7db240edb 100644
--- a/posthog/mcp/types.py
+++ b/posthog/mcp/types.py
@@ -242,6 +242,10 @@ class MCPAnalyticsOptions:
     # Return the alternative names that one tool accepts. The SDK records alias
     # use but does not change tool arguments.
     resolve_input_aliases: Optional[ResolveInputAliasesFn] = None
+    # Return the original tool descriptor for a low-level server. The SDK uses
+    # its input schema to remove only PostHog-owned arguments on a fresh server
+    # instance that did not serve tools/list.
+    resolve_original_tool: Optional[Callable[[str], Any]] = None
 
 
 @dataclass
diff --git a/posthog/test/mcp/test_features_m4.py b/posthog/test/mcp/test_features_m4.py
index f1f7bc37f..561162cad 100644
--- a/posthog/test/mcp/test_features_m4.py
+++ b/posthog/test/mcp/test_features_m4.py
@@ -193,7 +193,7 @@ async def test_fastmcp_keeps_input_names_after_conversation_anchoring():
     assert properties["$mcp_input_keys"] == ["a", "b"]
 
 
-async def test_lowlevel_does_not_reuse_a_listed_schema_for_input_names():
+async def test_lowlevel_reuses_a_listed_schema_for_input_names():
     server = make_lowlevel()
     client = FakeClient()
     instrument(server, client)
@@ -205,7 +205,7 @@ async def test_lowlevel_does_not_reuse_a_listed_schema_for_input_names():
     await _flush()
 
     properties = _events(client, "$mcp_tool_call")[0]["properties"]
-    assert properties["$mcp_input_keys"] == ["[redacted]"]
+    assert properties["$mcp_input_keys"] == ["msg"]
 
 
 async def test_lowlevel_conversation_id_captured_and_prompt_back():
diff --git a/posthog/test/mcp/test_lowlevel.py b/posthog/test/mcp/test_lowlevel.py
index ac84541c8..b51a5a10a 100644
--- a/posthog/test/mcp/test_lowlevel.py
+++ b/posthog/test/mcp/test_lowlevel.py
@@ -386,3 +386,259 @@ async def test_initialize_emitted_once():
 
     assert len(_events(client, "$mcp_initialize")) == 1
     assert len(_events(client, "$mcp_tool_call")) == 2
+
+
+def _make_strict_ownership_server(input_schema):
+    server = Server("strict-lowlevel")
+    seen = []
+
+    @server.list_tools()
+    async def list_tools():
+        return [
+            mcp_types.Tool(
+                name="search_docs",
+                inputSchema=input_schema,
+            )
+        ]
+
+    @server.call_tool()
+    async def call_tool(name, arguments):
+        seen.append(dict(arguments or {}))
+        allowed = set(input_schema.get("properties", {}))
+        unexpected = set(arguments or {}) - allowed
+        if unexpected:
+            raise ValueError(f"Unexpected arguments: {sorted(unexpected)}")
+        return [mcp_types.TextContent(type="text", text="ok")]
+
+    return server, seen
+
+
+async def test_listing_does_not_mutate_tool_used_by_fresh_resolver():
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    tool = mcp_types.Tool(name="search_docs", inputSchema=schema)
+
+    def make_server():
+        server = Server("reused-tool")
+        seen = []
+
+        @server.list_tools()
+        async def list_tools():
+            return [tool]
+
+        @server.call_tool()
+        async def call_tool(name, arguments):
+            seen.append(dict(arguments or {}))
+            return [mcp_types.TextContent(type="text", text="ok")]
+
+        return server, seen
+
+    first, _ = make_server()
+    instrument(first, FakeClient(), MCPAnalyticsOptions(enable_conversation_id=False))
+    await first.request_handlers[mcp_types.ListToolsRequest](
+        mcp_types.ListToolsRequest(method="tools/list")
+    )
+    assert tool.inputSchema == schema
+
+    second, seen = make_server()
+    instrument(
+        second,
+        FakeClient(),
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: tool,
+        ),
+    )
+    await second.request_handlers[mcp_types.CallToolRequest](
+        _call_request(
+            "search_docs",
+            {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+        )
+    )
+
+    assert seen == [{"query": "flags"}]
+
+
+async def test_lowlevel_keeps_top_level_reference_schema_unchanged():
+    schema = {
+        "$ref": "#/$defs/Input",
+        "$defs": {
+            "Input": {
+                "type": "object",
+                "properties": {
+                    "context": {"type": "string"},
+                    "conversation_id": {"type": "string"},
+                    "llm_model": {"type": "string"},
+                },
+            }
+        },
+    }
+    server, _ = _make_strict_ownership_server(schema)
+    instrument(server, FakeClient())
+
+    result = await server.request_handlers[mcp_types.ListToolsRequest](
+        mcp_types.ListToolsRequest(method="tools/list")
+    )
+
+    assert result.root.tools[0].inputSchema == schema
+
+
+async def test_fresh_lowlevel_resolver_strips_posthog_arguments():
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server(schema)
+    client = FakeClient()
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: {"inputSchema": schema},
+        ),
+    )
+
+    result = await server.request_handlers[mcp_types.CallToolRequest](
+        _call_request(
+            "search_docs",
+            {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+        )
+    )
+    await _flush()
+
+    assert result.root.isError is False
+    assert seen == [{"query": "flags"}]
+    props = _events(client, "$mcp_tool_call")[0]["properties"]
+    assert props["$mcp_intent"] == "find docs"
+    assert props["$mcp_llm_model"] == "model-a"
+    assert props["$mcp_input_keys"] == ["query"]
+
+
+async def test_fresh_lowlevel_resolver_preserves_tool_owned_context():
+    schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+            "context": {"type": "string"},
+        },
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server(schema)
+    client = FakeClient()
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            capture_model=False,
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: {"input_schema": schema},
+        ),
+    )
+
+    await server.request_handlers[mcp_types.CallToolRequest](
+        _call_request("search_docs", {"query": "flags", "context": "tool context"})
+    )
+    await _flush()
+
+    assert seen == [{"query": "flags", "context": "tool context"}]
+    props = _events(client, "$mcp_tool_call")[0]["properties"]
+    assert "$mcp_intent" not in props
+    captured = props["$mcp_parameters"]["request"]["params"]["arguments"]
+    assert captured["context"] == "tool context"
+
+
+@pytest.mark.parametrize(
+    "failure", ["none", "raise", "missing_schema", "schema_property_raises"]
+)
+async def test_fresh_lowlevel_resolver_failure_keeps_arguments(failure):
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server(schema)
+    client = FakeClient()
+    messages = []
+
+    class BrokenDescriptor:
+        @property
+        def inputSchema(self):
+            raise RuntimeError("schema unavailable")
+
+    def resolver(_name):
+        if failure == "raise":
+            raise RuntimeError("registry unavailable")
+        if failure == "missing_schema":
+            return {"name": "search_docs"}
+        if failure == "schema_property_raises":
+            return BrokenDescriptor()
+        return None
+
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            logger=messages.append,
+            resolve_original_tool=resolver,
+        ),
+    )
+
+    await server.request_handlers[mcp_types.CallToolRequest](
+        _call_request(
+            "search_docs",
+            {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+        )
+    )
+
+    assert seen == [{"query": "flags", "context": "find docs", "llm_model": "model-a"}]
+    warnings = [
+        message for message in messages if "resolve_original_tool failed" in message
+    ]
+    assert len(warnings) == int(failure != "none")
+
+
+async def test_lowlevel_served_listing_has_priority_over_resolver():
+    schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+            "context": {"type": "string"},
+        },
+    }
+    resolver_calls = []
+    server, seen = _make_strict_ownership_server(schema)
+
+    def resolver(name):
+        resolver_calls.append(name)
+        return {
+            "inputSchema": {
+                "type": "object",
+                "properties": {"query": {"type": "string"}},
+            }
+        }
+
+    client = FakeClient()
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            capture_model=False,
+            enable_conversation_id=False,
+            resolve_original_tool=resolver,
+        ),
+    )
+    await server.request_handlers[mcp_types.ListToolsRequest](
+        mcp_types.ListToolsRequest(method="tools/list")
+    )
+    await server.request_handlers[mcp_types.CallToolRequest](
+        _call_request("search_docs", {"query": "flags", "context": "tool context"})
+    )
+
+    assert resolver_calls == []
+    assert seen == [{"query": "flags", "context": "tool context"}]
diff --git a/posthog/test/mcp/test_types.py b/posthog/test/mcp/test_types.py
index e8a3f5424..98e437aac 100644
--- a/posthog/test/mcp/test_types.py
+++ b/posthog/test/mcp/test_types.py
@@ -1,8 +1,23 @@
 from unittest.mock import Mock
+from types import SimpleNamespace
 
 import pytest
 
 from posthog.mcp.types import MCPAnalyticsOptions, PreparedToolCall, UserIdentity
+from posthog.mcp._argument_ownership import _descriptor_input_schema
+
+
+@pytest.mark.parametrize(
+    "descriptor",
+    [
+        {"inputSchema": {"type": "object"}},
+        {"input_schema": {"type": "object"}},
+        SimpleNamespace(inputSchema={"type": "object"}),
+        SimpleNamespace(input_schema={"type": "object"}),
+    ],
+)
+def test_original_tool_descriptor_schema_shapes(descriptor):
+    assert _descriptor_input_schema(descriptor) == {"type": "object"}
 
 
 @pytest.mark.parametrize("capture_model", [False, True])
diff --git a/posthog/test/mcp/test_v2_lowlevel.py b/posthog/test/mcp/test_v2_lowlevel.py
index d923be04d..905292b1d 100644
--- a/posthog/test/mcp/test_v2_lowlevel.py
+++ b/posthog/test/mcp/test_v2_lowlevel.py
@@ -761,3 +761,269 @@ async def on_list_tools(ctx, params):
     assert result.content[0].text == get_more_tools_result_text()
     assert _events(client, "$mcp_missing_capability")
     assert not [m for m in messages if "Cannot inject PostHog's" in m]
+
+
+def _make_strict_ownership_server_v2(input_schema):
+    seen = []
+
+    async def on_call_tool(ctx, params):
+        arguments = dict(params.arguments or {})
+        seen.append(arguments)
+        allowed = set(input_schema.get("properties", {}))
+        unexpected = set(arguments) - allowed
+        if unexpected:
+            raise ValueError(f"Unexpected arguments: {sorted(unexpected)}")
+        return mcp_types.CallToolResult(
+            content=[mcp_types.TextContent(type="text", text="ok")]
+        )
+
+    async def on_list_tools(ctx, params):
+        return mcp_types.ListToolsResult(
+            tools=[
+                mcp_types.Tool(
+                    name="search_docs",
+                    input_schema=input_schema,
+                )
+            ]
+        )
+
+    return (
+        Server(
+            "strict-lowlevel-v2",
+            on_call_tool=on_call_tool,
+            on_list_tools=on_list_tools,
+        ),
+        seen,
+    )
+
+
+async def test_v2_fresh_lowlevel_resolver_strips_posthog_arguments():
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server_v2(schema)
+    client = FakeClient()
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: {"input_schema": schema},
+        ),
+    )
+
+    result = await _call_tool(
+        server,
+        "search_docs",
+        {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+    )
+    await _flush()
+
+    assert result.is_error is False
+    assert seen == [{"query": "flags"}]
+    props = _events(client, "$mcp_tool_call")[0]["properties"]
+    assert props["$mcp_intent"] == "find docs"
+    assert props["$mcp_llm_model"] == "model-a"
+    assert props["$mcp_input_keys"] == ["query"]
+
+
+async def test_v2_listing_does_not_mutate_tool_used_by_fresh_resolver():
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    tool = mcp_types.Tool(name="search_docs", input_schema=schema)
+
+    def make_server():
+        seen = []
+
+        async def on_call_tool(ctx, params):
+            seen.append(dict(params.arguments or {}))
+            return mcp_types.CallToolResult(
+                content=[mcp_types.TextContent(type="text", text="ok")]
+            )
+
+        async def on_list_tools(ctx, params):
+            return mcp_types.ListToolsResult(tools=[tool])
+
+        return (
+            Server(
+                "reused-tool-v2",
+                on_call_tool=on_call_tool,
+                on_list_tools=on_list_tools,
+            ),
+            seen,
+        )
+
+    first, _ = make_server()
+    instrument(first, FakeClient(), MCPAnalyticsOptions(enable_conversation_id=False))
+    await _list_tools(first)
+    assert tool.input_schema == schema
+
+    second, seen = make_server()
+    instrument(
+        second,
+        FakeClient(),
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: tool,
+        ),
+    )
+    await _call_tool(
+        second,
+        "search_docs",
+        {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+    )
+
+    assert seen == [{"query": "flags"}]
+
+
+async def test_v2_lowlevel_keeps_top_level_reference_schema_unchanged():
+    schema = {
+        "$ref": "#/$defs/Input",
+        "$defs": {
+            "Input": {
+                "type": "object",
+                "properties": {
+                    "context": {"type": "string"},
+                    "conversation_id": {"type": "string"},
+                    "llm_model": {"type": "string"},
+                },
+            }
+        },
+    }
+    server, _ = _make_strict_ownership_server_v2(schema)
+    instrument(server, FakeClient())
+
+    result = await _list_tools(server)
+
+    assert result.tools[0].input_schema == schema
+
+
+async def test_v2_fresh_lowlevel_resolver_preserves_tool_owned_context():
+    schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+            "context": {"type": "string"},
+        },
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server_v2(schema)
+    client = FakeClient()
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            capture_model=False,
+            enable_conversation_id=False,
+            resolve_original_tool=lambda _name: {"inputSchema": schema},
+        ),
+    )
+
+    await _call_tool(
+        server,
+        "search_docs",
+        {"query": "flags", "context": "tool context"},
+    )
+    await _flush()
+
+    assert seen == [{"query": "flags", "context": "tool context"}]
+    props = _events(client, "$mcp_tool_call")[0]["properties"]
+    assert "$mcp_intent" not in props
+    captured = props["$mcp_parameters"]["request"]["params"]["arguments"]
+    assert captured["context"] == "tool context"
+
+
+@pytest.mark.parametrize(
+    "failure", ["none", "raise", "missing_schema", "schema_property_raises"]
+)
+async def test_v2_fresh_lowlevel_resolver_failure_keeps_arguments(failure):
+    schema = {
+        "type": "object",
+        "properties": {"query": {"type": "string"}},
+        "additionalProperties": False,
+    }
+    server, seen = _make_strict_ownership_server_v2(schema)
+    client = FakeClient()
+    messages = []
+
+    class BrokenDescriptor:
+        @property
+        def inputSchema(self):
+            raise RuntimeError("schema unavailable")
+
+    def resolver(_name):
+        if failure == "raise":
+            raise RuntimeError("registry unavailable")
+        if failure == "missing_schema":
+            return {"name": "search_docs"}
+        if failure == "schema_property_raises":
+            return BrokenDescriptor()
+        return None
+
+    instrument(
+        server,
+        client,
+        MCPAnalyticsOptions(
+            enable_conversation_id=False,
+            logger=messages.append,
+            resolve_original_tool=resolver,
+        ),
+    )
+
+    with pytest.raises(ValueError, match="Unexpected arguments"):
+        await _call_tool(
+            server,
+            "search_docs",
+            {"query": "flags", "context": "find docs", "llm_model": "model-a"},
+        )
+
+    assert seen == [{"query": "flags", "context": "find docs", "llm_model": "model-a"}]
+    warnings = [
+        message for message in messages if "resolve_original_tool failed" in message
+    ]
+    assert len(warnings) == int(failure != "none")
+
+
+async def test_v2_lowlevel_served_listing_has_priority_over_resolver():
+    schema = {
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+            "context": {"type": "string"},
+        },
+    }
+    resolver_calls = []
+    server, seen = _make_strict_ownership_server_v2(schema)
+
+    def resolver(name):
+        resolver_calls.append(name)
+        return {
+            "input_schema": {
+                "type": "object",
+                "properties": {"query": {"type": "string"}},
+            }
+        }
+
+    instrument(
+        server,
+        FakeClient(),
+        MCPAnalyticsOptions(
+            capture_model=False,
+            enable_conversation_id=False,
+            resolve_original_tool=resolver,
+        ),
+    )
+    await _list_tools(server)
+    await _call_tool(
+        server,
+        "search_docs",
+        {"query": "flags", "context": "tool context"},
+    )
+
+    assert resolver_calls == []
+    assert seen == [{"query": "flags", "context": "tool context"}]
diff --git a/posthog/test/mcp/test_virtual_tools.py b/posthog/test/mcp/test_virtual_tools.py
index 9c5bea29b..c02ecc7bf 100644
--- a/posthog/test/mcp/test_virtual_tools.py
+++ b/posthog/test/mcp/test_virtual_tools.py
@@ -290,10 +290,9 @@ async def test_renamed_tool_is_intercepted_and_the_default_name_is_not():
     assert len(_events(client, "$mcp_missing_capability")) == 1
 
 
-async def test_real_tool_named_get_more_tools_keeps_normal_injection():
-    # With report_missing off the SDK advertises no such tool, so one by that
-    # name is an ordinary application tool: it gets `context` injected and its
-    # value captured as $mcp_intent, like any other tool's.
+async def test_real_tool_named_get_more_tools_keeps_tool_owned_context():
+    # With report_missing off the SDK advertises no such virtual tool. A real
+    # tool with this name keeps its declared `context` argument as tool data.
     server = make_paged_lowlevel([[_REAL_GET_MORE_TOOLS]])
     client = FakeClient()
     instrument(server, client, MCPAnalyticsOptions(report_missing=False, context=True))
@@ -305,7 +304,11 @@ async def test_real_tool_named_get_more_tools_keeps_normal_injection():
     assert out.root.content[0].text == "real tool ran"
     calls = _events(client, "$mcp_tool_call")
     assert calls
-    assert calls[0]["properties"]["$mcp_intent"] == "delete a cohort"
+    properties = calls[0]["properties"]
+    assert "$mcp_intent" not in properties
+    assert properties["$mcp_parameters"]["request"]["params"]["arguments"] == {
+        "context": "delete a cohort"
+    }
 
 
 # --- a host that reuses one result object --------------------------------------
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 8c3300ec1..71fbc14f2 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -977,6 +977,7 @@ attribute posthog.mcp.types.MCPAnalyticsOptions.logger: Optional[LoggerFn] = Non
 attribute posthog.mcp.types.MCPAnalyticsOptions.missing_capability_tool_name: Optional[str] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.report_missing: bool = False
 attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_input_aliases: Optional[ResolveInputAliasesFn] = None
+attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_original_tool: Optional[Callable[[str], Any]] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.server_build: Optional[str] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.should_record_input_key: Optional[ShouldRecordInputKeyFn] = None
 attribute posthog.mcp.types.PreparedToolCall.args: Optional[JsonRecord] = None
@@ -1219,7 +1220,7 @@ class posthog.mcp.types.CollectFeedbackOptions(tool_name: Optional[str] = None,
 class posthog.mcp.types.FeedbackReport(feedback_type: str = 'other', summary: str = '', sentiment: Optional[str] = None, friction_points: Optional[str] = None, suggested_improvement: Optional[str] = None, details: Optional[str] = None, tool_name: Optional[str] = None, task_completed: Optional[bool] = None, extras: JsonRecord = dict(), raw: JsonRecord = dict())
 class posthog.mcp.types.MCPAnalyticsContextOptions(description: Optional[str] = None)
 class posthog.mcp.types.MCPAnalyticsModelOptions(description: Optional[str] = None)
-class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None)
+class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None, resolve_original_tool: Optional[Callable[[str], Any]] = None)
 class posthog.mcp.types.PreparedToolCall(args: Optional[JsonRecord] = None, intent: Optional[str] = None, intent_source: Optional[str] = None, is_missing_capability: bool = False, llm_model: Optional[str] = None, llm_model_source: Optional[MCPAnalyticsModelSource] = None, is_feedback: bool = False, feedback_report: Optional[FeedbackReport] = None, session_id: Optional[str] = None, conversation_id: Optional[str] = None, _conversation_state: Optional[PreparedConversationState] = None)
 class posthog.mcp.types.ToolInputOptions(should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, input_aliases: Optional[InputAliasMap] = None)
 class posthog.mcp.types.UserIdentity(distinct_id: str, properties: Optional[JsonRecord] = None, groups: Optional[Dict[str, str]] = None)

From 292855d1f267ad50e9c3b8341c9fbc839b36cf5c Mon Sep 17 00:00:00 2001
From: Hugues Pouillot <hpouillot@gmail.com>
Date: Thu, 8 Oct 2026 16:29:26 +0200
Subject: [PATCH 007/245] feat(flask): add error tracking integration (#1038)

* feat(flask): add error tracking integration

* fix(flask): use canonical exception metadata

* chore(flask): type exception capture metadata

* refactor(flask): expose request properties terminology

* fix(flask): preserve exception privacy settings
---
 .sampo/changesets/flask-error-tracking.md     |   5 +
 posthog/integrations/flask.py                 | 262 ++++++++++++++++++
 .../integrations/test_flask_integration.py    | 260 +++++++++++++++++
 pyproject.toml                                |   1 +
 references/public_api_snapshot.txt            |   7 +
 uv.lock                                       |  71 ++++-
 6 files changed, 601 insertions(+), 5 deletions(-)
 create mode 100644 .sampo/changesets/flask-error-tracking.md
 create mode 100644 posthog/integrations/flask.py
 create mode 100644 posthog/test/integrations/test_flask_integration.py

diff --git a/.sampo/changesets/flask-error-tracking.md b/.sampo/changesets/flask-error-tracking.md
new file mode 100644
index 000000000..4e4bcf30d
--- /dev/null
+++ b/.sampo/changesets/flask-error-tracking.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add a Flask integration that creates isolated request contexts, attaches safe request metadata and tracing identity, and automatically captures unhandled application exceptions without changing Flask's error behavior.
diff --git a/posthog/integrations/flask.py b/posthog/integrations/flask.py
new file mode 100644
index 000000000..9a4bf4305
--- /dev/null
+++ b/posthog/integrations/flask.py
@@ -0,0 +1,262 @@
+"""Flask request context and exception tracking integration.
+
+Flask is imported lazily when :meth:`PosthogFlaskIntegration.init_app` is called,
+so importing the PostHog SDK does not require Flask to be installed.
+
+Example::
+
+    from flask import Flask
+    from posthog.integrations.flask import PosthogFlaskIntegration
+
+    app = Flask(__name__)
+    PosthogFlaskIntegration(app)
+"""
+
+from __future__ import annotations
+
+import re
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, cast
+
+from .. import contexts
+from ..client import Client
+from ..exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+)
+
+if TYPE_CHECKING:
+    from flask import Flask, Request
+
+
+__all__ = ["PosthogFlaskIntegration"]
+
+_MAX_TRACING_HEADER_LENGTH = 1000
+_TRACING_HEADER_CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f-\x9f]")
+_EXTENSION_KEY = "posthog"
+_REQUEST_STATE_KEY = "_posthog_integration_state"
+
+
+def _sanitize_tracing_header_value(value: object) -> Optional[str]:
+    """Return a bounded tracing header value safe for event properties."""
+    if not isinstance(value, str) or not value:
+        return None
+
+    return (
+        _TRACING_HEADER_CONTROL_CHARS_RE.sub("", value).strip()[
+            :_MAX_TRACING_HEADER_LENGTH
+        ]
+        or None
+    )
+
+
+@dataclass
+class _RequestState:
+    scope: AbstractContextManager[None]
+    tracked: bool = True
+
+
+@dataclass(frozen=True)
+class _ExceptionPrivacySettings:
+    capture_code_variables: Optional[bool]
+    mask_patterns: Optional[list]
+    ignore_patterns: Optional[list]
+    mask_url_credentials: Optional[bool]
+    detect_secrets: Optional[bool]
+
+    @classmethod
+    def from_current_context(cls) -> _ExceptionPrivacySettings:
+        """Snapshot effective privacy controls before entering a fresh request scope."""
+        return cls(
+            capture_code_variables=contexts.get_capture_exception_code_variables_context(),
+            mask_patterns=contexts.get_code_variables_mask_patterns_context(),
+            ignore_patterns=contexts.get_code_variables_ignore_patterns_context(),
+            mask_url_credentials=contexts.get_code_variables_mask_url_credentials_context(),
+            detect_secrets=contexts.get_code_variables_detect_secrets_context(),
+        )
+
+    def apply(self) -> None:
+        """Apply inherited privacy controls without restoring identity or properties."""
+        if self.capture_code_variables is not None:
+            contexts.set_capture_exception_code_variables_context(
+                self.capture_code_variables
+            )
+        if self.mask_patterns is not None:
+            contexts.set_code_variables_mask_patterns_context(self.mask_patterns)
+        if self.ignore_patterns is not None:
+            contexts.set_code_variables_ignore_patterns_context(self.ignore_patterns)
+        if self.mask_url_credentials is not None:
+            contexts.set_code_variables_mask_url_credentials_context(
+                self.mask_url_credentials
+            )
+        if self.detect_secrets is not None:
+            contexts.set_code_variables_detect_secrets_context(self.detect_secrets)
+
+
+class PosthogFlaskIntegration:
+    """Add PostHog request context and exception tracking to a Flask app.
+
+    Args:
+        app: An optional Flask application. If omitted, call :meth:`init_app`
+            later (the Flask application-factory pattern).
+        client: Optional PostHog client used to capture exceptions. The global
+            client is used by default.
+        capture_exceptions: Capture exceptions that reach Flask's unhandled
+            exception machinery. Defaults to ``True``.
+        request_filter: Optional callback receiving Flask's request object. A
+            false return value disables both context and exception capture for
+            that request.
+        extra_properties: Optional callback returning additional event properties.
+            This is useful for application-specific metadata such as an authenticated
+            user's role. Values should not contain secrets or request bodies.
+
+    The integration intentionally does not capture exceptions handled by an
+    application error handler, expected HTTP exceptions, request or response
+    bodies, query strings, cookies, authorization headers, or arbitrary headers.
+    Call ``capture_exception`` explicitly from a custom error handler if a
+    handled exception should be reported.
+    """
+
+    def __init__(
+        self,
+        app: Optional[Flask] = None,
+        *,
+        client: Optional[Client] = None,
+        capture_exceptions: bool = True,
+        request_filter: Optional[Callable[[Request], bool]] = None,
+        extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None,
+    ) -> None:
+        self.client = client
+        self.capture_exceptions = capture_exceptions
+        self.request_filter = request_filter
+        self.extra_properties = extra_properties
+
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: Flask) -> None:
+        """Register the integration with a Flask application once."""
+        try:
+            from flask import got_request_exception
+        except ImportError as error:  # pragma: no cover - exercised without Flask
+            raise RuntimeError(
+                "PosthogFlaskIntegration requires Flask to be installed"
+            ) from error
+
+        if _EXTENSION_KEY in app.extensions:
+            raise RuntimeError("PostHog is already initialized for this Flask app")
+
+        app.extensions[_EXTENSION_KEY] = self
+        app.before_request(self._before_request)
+        app.teardown_request(self._teardown_request)
+        got_request_exception.connect(self._handle_unhandled_exception, app, weak=False)
+
+    def _before_request(self) -> None:
+        from flask import g, request
+
+        if self.request_filter is not None and not self.request_filter(request):
+            setattr(g, _REQUEST_STATE_KEY, None)
+            return
+
+        # A request gets fresh identity and event properties, but privacy controls
+        # must remain at least as strict as the effective enclosing context.
+        privacy_settings = _ExceptionPrivacySettings.from_current_context()
+
+        # Flask handles application exceptions before returning control through
+        # the request stack, so capture through got_request_exception rather than
+        # through new_context. This also avoids duplicate capture.
+        scope = contexts.new_context(
+            fresh=True,
+            capture_exceptions=False,
+            client=self.client,
+        )
+        scope.__enter__()
+        privacy_settings.apply()
+        setattr(g, _REQUEST_STATE_KEY, _RequestState(scope=scope))
+
+        session_id = _sanitize_tracing_header_value(
+            request.headers.get("X-POSTHOG-SESSION-ID")
+        )
+        if session_id:
+            contexts.set_context_session(session_id)
+
+        distinct_id = _sanitize_tracing_header_value(
+            request.headers.get("X-POSTHOG-DISTINCT-ID")
+        )
+        if distinct_id:
+            contexts.identify_context(distinct_id)
+
+        for key, value in self._request_properties(request).items():
+            contexts.tag(key, value)
+
+        if self.extra_properties is not None:
+            extra_properties = self.extra_properties(request)
+            if extra_properties:
+                for key, value in extra_properties.items():
+                    contexts.tag(key, value)
+
+    @staticmethod
+    def _request_properties(request: Request) -> dict[str, Any]:
+        properties: dict[str, Any] = {
+            # base_url deliberately excludes query strings, which commonly
+            # contain credentials, tokens, and other sensitive values.
+            "$current_url": request.base_url,
+            "$request_method": request.method,
+            "$request_path": request.path,
+        }
+
+        if request.remote_addr:
+            properties["$ip"] = request.remote_addr
+
+        user_agent = request.headers.get("User-Agent")
+        if user_agent:
+            properties["$user_agent"] = user_agent
+            properties["$raw_user_agent"] = user_agent
+
+        url_rule = getattr(request, "url_rule", None)
+        if url_rule is not None:
+            properties["$request_route"] = str(url_rule)
+
+        return properties
+
+    def _handle_unhandled_exception(
+        self, sender: Flask, exception: BaseException, **kwargs: Any
+    ) -> None:
+        if not self.capture_exceptions or not self._request_is_tracked():
+            return
+
+        capture_metadata: _ExceptionCaptureMetadata = {
+            "level": "error",
+            "source": "flask.got_request_exception",
+            "mechanism": {"type": "middleware", "handled": False},
+        }
+        if self.client is not None:
+            _capture_exception_with_metadata(self.client, exception, capture_metadata)
+        else:
+            # Keep this import relative so the generated posthoganalytics mirror
+            # resolves its own global client rather than the posthog package.
+            from .. import capture_exception
+
+            cast(Any, capture_exception)(exception, _capture_metadata=capture_metadata)
+
+    @staticmethod
+    def _request_is_tracked() -> bool:
+        from flask import g, has_request_context
+
+        if not has_request_context():
+            return False
+        state = getattr(g, _REQUEST_STATE_KEY, None)
+        return isinstance(state, _RequestState) and state.tracked
+
+    def _teardown_request(self, exception: Optional[BaseException]) -> None:
+        from flask import g
+
+        state = getattr(g, _REQUEST_STATE_KEY, None)
+        if not isinstance(state, _RequestState):
+            return
+
+        # The Flask signal already captured any unhandled exception. Close the
+        # context normally so new_context cannot capture it a second time.
+        setattr(g, _REQUEST_STATE_KEY, None)
+        state.scope.__exit__(None, None, None)
diff --git a/posthog/test/integrations/test_flask_integration.py b/posthog/test/integrations/test_flask_integration.py
new file mode 100644
index 000000000..4df637ff2
--- /dev/null
+++ b/posthog/test/integrations/test_flask_integration.py
@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+from flask import Flask, abort, jsonify
+
+from posthog import contexts
+from posthog.integrations.flask import (
+    PosthogFlaskIntegration,
+    _sanitize_tracing_header_value,
+)
+
+
+def _app() -> Flask:
+    app = Flask(__name__)
+    app.config.update(TESTING=True)
+    return app
+
+
+def test_adds_request_context_and_restores_parent_context() -> None:
+    app = _app()
+    PosthogFlaskIntegration(app, extra_properties=lambda request: {"tenant": "acme"})
+
+    @app.get("/users/<user_id>")
+    def view(user_id: str):
+        scope = contexts._get_current_context()
+        assert scope is not None
+        return jsonify(
+            distinct_id=contexts.get_context_distinct_id(),
+            session_id=contexts.get_context_session_id(),
+            properties=scope.collect_tags(),
+        )
+
+    with contexts.new_context():
+        contexts.tag("outer", "must-not-leak-into-request")
+        response = app.test_client().get(
+            "/users/123?access_token=secret",
+            headers={
+                "X-PostHog-Distinct-Id": "  person-1  ",
+                "X-PostHog-Session-Id": " session-1 ",
+                "User-Agent": "integration-test/1.0",
+            },
+            environ_base={"REMOTE_ADDR": "203.0.113.10"},
+        )
+
+        payload = response.get_json()
+        assert payload["distinct_id"] == "person-1"
+        assert payload["session_id"] == "session-1"
+        assert payload["properties"] == {
+            "$current_url": "http://localhost/users/123",
+            "$ip": "203.0.113.10",
+            "$raw_user_agent": "integration-test/1.0",
+            "$request_method": "GET",
+            "$request_path": "/users/123",
+            "$request_route": "/users/<user_id>",
+            "$user_agent": "integration-test/1.0",
+            "tenant": "acme",
+        }
+        assert "secret" not in payload["properties"]["$current_url"]
+
+        parent = contexts._get_current_context()
+        assert parent is not None
+        assert parent.collect_tags() == {"outer": "must-not-leak-into-request"}
+
+
+def test_fresh_request_preserves_enclosing_exception_privacy_settings() -> None:
+    app = _app()
+    client = Mock()
+    observed = {}
+
+    def capture(exception, **kwargs):
+        scope = contexts._get_current_context()
+        assert scope is not None
+        observed.update(
+            capture_code_variables=contexts.get_capture_exception_code_variables_context(),
+            mask_patterns=contexts.get_code_variables_mask_patterns_context(),
+            ignore_patterns=contexts.get_code_variables_ignore_patterns_context(),
+            mask_url_credentials=contexts.get_code_variables_mask_url_credentials_context(),
+            detect_secrets=contexts.get_code_variables_detect_secrets_context(),
+            distinct_id=contexts.get_context_distinct_id(),
+            session_id=contexts.get_context_session_id(),
+            properties=scope.collect_tags(),
+        )
+        return "event-id"
+
+    client.capture_exception.side_effect = capture
+    PosthogFlaskIntegration(app, client=client)
+
+    @app.get("/privacy")
+    def privacy_failure():
+        raise ValueError("privacy settings")
+
+    with contexts.new_context():
+        contexts.set_capture_exception_code_variables_context(False)
+        contexts.set_code_variables_mask_patterns_context(["secret"])
+        contexts.set_code_variables_ignore_patterns_context(["ignored"])
+        contexts.set_code_variables_mask_url_credentials_context(True)
+        contexts.set_code_variables_detect_secrets_context(True)
+        contexts.identify_context("outer-person")
+        contexts.set_context_session("outer-session")
+        contexts.tag("outer-property", "must-not-leak")
+
+        with pytest.raises(ValueError, match="privacy settings"):
+            app.test_client().get("/privacy")
+
+        # Teardown restores the enclosing context unchanged.
+        assert contexts.get_capture_exception_code_variables_context() is False
+        assert contexts.get_code_variables_mask_patterns_context() == ["secret"]
+        assert contexts.get_code_variables_ignore_patterns_context() == ["ignored"]
+        assert contexts.get_code_variables_mask_url_credentials_context() is True
+        assert contexts.get_code_variables_detect_secrets_context() is True
+
+    properties = observed.pop("properties")
+    assert properties["$request_path"] == "/privacy"
+    assert "outer-property" not in properties
+    assert observed == {
+        "capture_code_variables": False,
+        "mask_patterns": ["secret"],
+        "ignore_patterns": ["ignored"],
+        "mask_url_credentials": True,
+        "detect_secrets": True,
+        # Identity remains isolated by the fresh scope.
+        "distinct_id": None,
+        "session_id": None,
+    }
+
+
+def test_captures_unhandled_exception_once_with_request_properties() -> None:
+    app = _app()
+    client = Mock()
+    captures = []
+
+    def capture(exception, **kwargs):
+        scope = contexts._get_current_context()
+        assert scope is not None
+        captures.append((exception, kwargs, scope.collect_tags()))
+        return "event-id"
+
+    client.capture_exception.side_effect = capture
+    PosthogFlaskIntegration(app, client=client)
+    error = ValueError("view failed")
+
+    @app.get("/failure")
+    def failure():
+        raise error
+
+    with pytest.raises(ValueError, match="view failed"):
+        app.test_client().get("/failure")
+
+    assert len(captures) == 1
+    exception, kwargs, properties = captures[0]
+    assert exception is error
+    assert kwargs == {
+        "_capture_metadata": {
+            "level": "error",
+            "source": "flask.got_request_exception",
+            "mechanism": {"type": "middleware", "handled": False},
+        }
+    }
+    assert properties["$request_path"] == "/failure"
+    assert contexts._get_current_context() is None
+
+
+def test_uses_global_client_when_custom_client_is_not_provided() -> None:
+    app = _app()
+    PosthogFlaskIntegration(app)
+    error = RuntimeError("boom")
+
+    @app.get("/failure")
+    def failure():
+        raise error
+
+    with patch("posthog.capture_exception", return_value="event-id") as capture:
+        with pytest.raises(RuntimeError, match="boom"):
+            app.test_client().get("/failure")
+
+    capture.assert_called_once_with(
+        error,
+        _capture_metadata={
+            "level": "error",
+            "source": "flask.got_request_exception",
+            "mechanism": {"type": "middleware", "handled": False},
+        },
+    )
+
+
+def test_does_not_capture_handled_exception_or_expected_http_error() -> None:
+    app = _app()
+    client = Mock()
+    PosthogFlaskIntegration(app, client=client)
+
+    @app.errorhandler(ValueError)
+    def handle_value_error(error):
+        return {"error": str(error)}, 422
+
+    @app.get("/handled")
+    def handled():
+        raise ValueError("expected")
+
+    @app.get("/missing")
+    def missing():
+        abort(404)
+
+    assert app.test_client().get("/handled").status_code == 422
+    assert app.test_client().get("/missing").status_code == 404
+    client.capture_exception.assert_not_called()
+
+
+def test_capture_exceptions_can_be_disabled_without_changing_propagation() -> None:
+    app = _app()
+    client = Mock()
+    PosthogFlaskIntegration(app, client=client, capture_exceptions=False)
+
+    @app.get("/failure")
+    def failure():
+        raise LookupError("disabled")
+
+    with pytest.raises(LookupError, match="disabled"):
+        app.test_client().get("/failure")
+
+    client.capture_exception.assert_not_called()
+
+
+def test_request_filter_skips_context_and_exception_capture() -> None:
+    app = _app()
+    client = Mock()
+    PosthogFlaskIntegration(
+        app,
+        client=client,
+        request_filter=lambda request: request.path != "/ignored",
+    )
+
+    @app.get("/ignored")
+    def ignored():
+        assert contexts._get_current_context() is None
+        raise RuntimeError("ignored")
+
+    with pytest.raises(RuntimeError, match="ignored"):
+        app.test_client().get("/ignored")
+
+    client.capture_exception.assert_not_called()
+
+
+def test_supports_application_factory_pattern_and_rejects_duplicate_setup() -> None:
+    app = _app()
+    integration = PosthogFlaskIntegration()
+    integration.init_app(app)
+
+    assert app.extensions["posthog"] is integration
+
+    with pytest.raises(RuntimeError, match="already initialized"):
+        PosthogFlaskIntegration(app)
+
+
+def test_sanitizes_and_bounds_tracing_headers() -> None:
+    assert _sanitize_tracing_header_value("  person\n-\t1\x85  ") == "person-1"
+    assert _sanitize_tracing_header_value("\r\n") is None
+    assert _sanitize_tracing_header_value(123) is None
+    assert _sanitize_tracing_header_value("a" * 1001) == "a" * 1000
diff --git a/pyproject.toml b/pyproject.toml
index 741b39bb9..d9e9f7626 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -69,6 +69,7 @@ dev = [
 ]
 test = [
     "freezegun==1.5.1",
+    "flask>=2.2",
     "python-dateutil>=2.9.0.post0",
     "tzdata",
     "coverage",
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 71fbc14f2..32f085b62 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -882,6 +882,10 @@ attribute posthog.integrations.django.PosthogContextMiddleware.get_response = ge
 attribute posthog.integrations.django.PosthogContextMiddleware.request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
 attribute posthog.integrations.django.PosthogContextMiddleware.sync_capable = True
 attribute posthog.integrations.django.PosthogContextMiddleware.tag_map = cast('Optional[Callable[[Dict[str, Any]], Dict[str, Any]]]', settings.POSTHOG_MW_TAG_MAP)
+attribute posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions = capture_exceptions
+attribute posthog.integrations.flask.PosthogFlaskIntegration.client = client
+attribute posthog.integrations.flask.PosthogFlaskIntegration.extra_properties = extra_properties
+attribute posthog.integrations.flask.PosthogFlaskIntegration.request_filter = request_filter
 attribute posthog.is_server = True
 attribute posthog.log_captured_exceptions = False
 attribute posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware.app = app
@@ -1209,6 +1213,7 @@ class posthog.flag_definition_cache.FlagDefinitionCacheProvider
 class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: bool = True, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: bool = False)
 class posthog.integrations.celery.PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
 class posthog.integrations.django.PosthogContextMiddleware(get_response)
+class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: bool = True, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None)
 class posthog.mcp.McpAnalytics(key: Any)
 class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any)
 class posthog.mcp.constants.PostHogMCPAnalyticsEvent 
@@ -1677,6 +1682,7 @@ method posthog.integrations.django.PosthogContextMiddleware.aextract_tags(reques
 method posthog.integrations.django.PosthogContextMiddleware.extract_request_user(request)
 method posthog.integrations.django.PosthogContextMiddleware.extract_tags(request)
 method posthog.integrations.django.PosthogContextMiddleware.process_exception(request, exception)
+method posthog.integrations.flask.PosthogFlaskIntegration.init_app(app: Flask) -> None
 method posthog.mcp.McpAnalytics.capture(event: str, properties: Optional[dict] = None) -> None
 method posthog.mcp.McpAnalytics.flush() -> None
 method posthog.mcp.posthog_mcp.PostHogMCP.capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
@@ -1787,6 +1793,7 @@ module posthog.integrations
 module posthog.integrations.asgi
 module posthog.integrations.celery
 module posthog.integrations.django
+module posthog.integrations.flask
 module posthog.mcp
 module posthog.mcp.asgi
 module posthog.mcp.constants
diff --git a/uv.lock b/uv.lock
index cb51bfae6..80a39f29e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -29,7 +29,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "caio" },
+    { name = "caio", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" }
 wheels = [
@@ -49,7 +49,7 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "caio" },
+    { name = "caio", marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/48/41/2fea7e193e061ce54eacc3b7bc0e6a99e4fcff43c78cf0a76dd781ed8334/aiofile-3.11.1.tar.gz", hash = "sha256:1f91912c6643d2a4e49ca4ae3514f0bf3867ce948a36d99a6411b8f4755f4cf9", size = 19342, upload-time = "2026-05-16T08:18:33.538Z" }
 wheels = [
@@ -265,7 +265,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version != '3.11.*'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6a/68/fb4fb78c9eac59d5e819108a57664737f855c5a8e9b76aec1738bb137f9e/asgiref-3.9.0.tar.gz", hash = "sha256:3dd2556d0f08c4fab8a010d9ab05ef8c34565f6bf32381d17505f7ca5b273767", size = 36772, upload-time = "2025-07-03T13:25:01.491Z" }
 wheels = [
@@ -355,6 +355,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/cc/18245721fa7747065ab478316c7fea7c74777d07f37ae60db2e84f8172e8/beartype-0.22.9-py3-none-any.whl", hash = "sha256:d16c9bbc61ea14637596c5f6fbff2ee99cbe3573e46a716401734ef50c3060c2", size = 1333658, upload-time = "2025-12-13T06:50:28.266Z" },
 ]
 
+[[package]]
+name = "blinker"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/28/9b3f50ce0e048515135495f198351908d99540d69bfdc8c1d15b73dc55ce/blinker-1.9.0.tar.gz", hash = "sha256:b4ce2265a7abece45e7cc896e98dbebe6cead56bcf805a3d23136d145f5445bf", size = 22460, upload-time = "2024-11-08T17:25:47.436Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" },
+]
+
 [[package]]
 name = "cachetools"
 version = "7.1.6"
@@ -914,6 +923,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/01/a4/9b63d595d748e3aff8812b65eacc1a2c4bd90b7c2012e08e72373b4835eb/filelock-3.32.4-py3-none-any.whl", hash = "sha256:22e58ca3b1ae3b98993b762d7338367ae64fe50252bf78d59da3bfebcdf1cedd", size = 99864, upload-time = "2026-08-23T17:37:53.913Z" },
 ]
 
+[[package]]
+name = "flask"
+version = "3.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "blinker" },
+    { name = "click" },
+    { name = "itsdangerous" },
+    { name = "jinja2" },
+    { name = "markupsafe" },
+    { name = "werkzeug" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/00/35d85dcce6c57fdc871f3867d465d780f302a175ea360f62533f12b27e2b/flask-3.1.3.tar.gz", hash = "sha256:0ef0e52b8a9cd932855379197dd8f94047b359ca0a78695144304cb45f87c9eb", size = 759004, upload-time = "2026-02-19T05:00:57.678Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/9c/34f6962f9b9e9c71f6e5ed806e0d0ff03c9d1b0b2340088a0cf4bce09b18/flask-3.1.3-py3-none-any.whl", hash = "sha256:f4bcbefc124291925f1a26446da31a5178f9483862233b23c0c96a20701f670c", size = 103424, upload-time = "2026-02-19T05:00:56.027Z" },
+]
+
 [[package]]
 name = "freezegun"
 version = "1.5.1"
@@ -1361,6 +1387,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
 ]
 
+[[package]]
+name = "itsdangerous"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/cb/8ac0172223afbccb63986cc25049b154ecfb5e85932587206f42317be31d/itsdangerous-2.2.0.tar.gz", hash = "sha256:e0050c0b7da1eea53ffaf149c0cfbb5c6e2e2b69c4bef22c81fa6eb73e5f6173", size = 54410, upload-time = "2024-04-16T21:28:15.614Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/96/92447566d16df59b2a776c0fb82dbc4d9e07cd95062562af01e408583fc4/itsdangerous-2.2.0-py3-none-any.whl", hash = "sha256:c6242fc49e35958c8b15141343aa660db5fc54d4f13a1db01a3f5891b98700ef", size = 16234, upload-time = "2024-04-16T21:28:14.499Z" },
+]
+
 [[package]]
 name = "jaraco-classes"
 version = "3.4.0"
@@ -1406,6 +1441,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" },
 ]
 
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
 [[package]]
 name = "jiter"
 version = "0.10.0"
@@ -2814,6 +2861,7 @@ test = [
     { name = "coverage" },
     { name = "django" },
     { name = "fastmcp" },
+    { name = "flask" },
     { name = "freezegun" },
     { name = "gevent", marker = "implementation_name == 'cpython'" },
     { name = "google-genai" },
@@ -2859,6 +2907,7 @@ requires-dist = [
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -3766,8 +3815,8 @@ name = "secretstorage"
 version = "3.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography" },
-    { name = "jeepney" },
+    { name = "cryptography", marker = "python_full_version < '3.13' or sys_platform != 'win32'" },
+    { name = "jeepney", marker = "python_full_version < '3.13' or sys_platform != 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/53/a4/f48c9d79cb507ed1373477dbceaba7401fd8a23af63b837fa61f1dcd3691/SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77", size = 19739, upload-time = "2022-08-13T16:22:46.976Z" }
 wheels = [
@@ -4353,6 +4402,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
 ]
 
+[[package]]
+name = "werkzeug"
+version = "3.1.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a4/34/4dd12fc8bb7d61c91467ec3efe415ffa7d5456f799954b40c5bbaeae470e/werkzeug-3.1.9.tar.gz", hash = "sha256:55ca7c70a75689be937aa27f8ff4b018f06ff4838fc73045560bf0f5a1291060", size = 940188, upload-time = "2026-09-27T18:33:41.637Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/38/df03f564f43cec2684823f3cccae1a652ee7face1cbaa76fb223096e64d7/werkzeug-3.1.9-py3-none-any.whl", hash = "sha256:6392e50c78460ba618e5b21f08a71f59c99ce99cdc6cf6e3dd7e6ccca8754fab", size = 228700, upload-time = "2026-09-27T18:33:39.685Z" },
+]
+
 [[package]]
 name = "wheel"
 version = "0.45.1"

From d23ef68b2e72daa3bb30cc4b324ee339f354b8df Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 8 Oct 2026 14:31:52 +0000
Subject: [PATCH 008/245] chore: Release v7.66.0 [skip ci]

---
 .sampo/changesets/asgi-error-tracking.md         |  5 -----
 .sampo/changesets/flask-error-tracking.md        |  5 -----
 .sampo/changesets/mcp-lowlevel-tool-ownership.md |  7 -------
 openfeature-provider/CHANGELOG.md                |  6 ++++++
 openfeature-provider/pyproject.toml              |  2 +-
 posthog/CHANGELOG.md                             | 10 ++++++++++
 posthog/version.py                               |  2 +-
 pyproject.toml                                   |  2 +-
 uv.lock                                          | 14 +++++++-------
 9 files changed, 26 insertions(+), 27 deletions(-)
 delete mode 100644 .sampo/changesets/asgi-error-tracking.md
 delete mode 100644 .sampo/changesets/flask-error-tracking.md
 delete mode 100644 .sampo/changesets/mcp-lowlevel-tool-ownership.md

diff --git a/.sampo/changesets/asgi-error-tracking.md b/.sampo/changesets/asgi-error-tracking.md
deleted file mode 100644
index b52661e71..000000000
--- a/.sampo/changesets/asgi-error-tracking.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add framework-independent ASGI middleware for automatic request context and unhandled exception capture, supporting FastAPI, Starlette, Litestar, WebSockets, sync or async filters, additional request properties, and opt-in PostHog tracing headers without requiring a framework dependency.
diff --git a/.sampo/changesets/flask-error-tracking.md b/.sampo/changesets/flask-error-tracking.md
deleted file mode 100644
index 4e4bcf30d..000000000
--- a/.sampo/changesets/flask-error-tracking.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add a Flask integration that creates isolated request contexts, attaches safe request metadata and tracing identity, and automatically captures unhandled application exceptions without changing Flask's error behavior.
diff --git a/.sampo/changesets/mcp-lowlevel-tool-ownership.md b/.sampo/changesets/mcp-lowlevel-tool-ownership.md
deleted file mode 100644
index ec0a54a2c..000000000
--- a/.sampo/changesets/mcp-lowlevel-tool-ownership.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add `resolve_original_tool` for low-level MCP servers. Fresh server instances can now remove PostHog-owned arguments before strict tool validation.
-
-Raw low-level servers also remove PostHog-owned arguments after `tools/list`. A tool-owned `context` remains tool data.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 8c4f2ec3d..6f493d380 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.99 — 2026-10-08
+
+### Patch changes
+
+- Updated dependencies: posthog@7.66.0
+
 ## 0.1.98 — 2026-10-08
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 1338c0459..a85b9e803 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.98"
+version = "0.1.99"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 204a071ae..8033924e7 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,15 @@
 # posthog
 
+## 7.66.0 — 2026-10-08
+
+### Minor changes
+
+- [127009d](https://github.com/posthog/posthog-python/commit/127009dc394af6638a3ea8a88bdb0dcae46db0c3) Add `resolve_original_tool` for low-level MCP servers. Fresh server instances can now remove PostHog-owned arguments before strict tool validation.
+  
+  Raw low-level servers also remove PostHog-owned arguments after `tools/list`. A tool-owned `context` remains tool data. — Thanks @gesh!
+- [1c6a47a](https://github.com/posthog/posthog-python/commit/1c6a47ae235c127329c38db02cb6837a7f1c6434) Add framework-independent ASGI middleware for automatic request context and unhandled exception capture, supporting FastAPI, Starlette, Litestar, WebSockets, sync or async filters, additional request properties, and opt-in PostHog tracing headers without requiring a framework dependency. — Thanks @hpouillot!
+- [292855d](https://github.com/posthog/posthog-python/commit/292855d1f267ad50e9c3b8341c9fbc839b36cf5c) Add a Flask integration that creates isolated request contexts, attaches safe request metadata and tracing identity, and automatically captures unhandled application exceptions without changing Flask's error behavior. — Thanks @hpouillot!
+
 ## 7.65.0 — 2026-10-08
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 6d7e16a24..e185d24ea 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.65.0"
+VERSION = "7.66.0"
diff --git a/pyproject.toml b/pyproject.toml
index d9e9f7626..f4a0a31ab 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.65.0"
+version = "7.66.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 80a39f29e..406e0e5ed 100644
--- a/uv.lock
+++ b/uv.lock
@@ -29,7 +29,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "caio", marker = "python_full_version < '3.11'" },
+    { name = "caio" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/67/e2/d7cb819de8df6b5c1968a2756c3cb4122d4fa2b8fc768b53b7c9e5edb646/aiofile-3.9.0.tar.gz", hash = "sha256:e5ad718bb148b265b6df1b3752c4d1d83024b93da9bd599df74b9d9ffcf7919b", size = 17943, upload-time = "2024-10-08T10:39:35.846Z" }
 wheels = [
@@ -49,7 +49,7 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "caio", marker = "python_full_version >= '3.11'" },
+    { name = "caio" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/48/41/2fea7e193e061ce54eacc3b7bc0e6a99e4fcff43c78cf0a76dd781ed8334/aiofile-3.11.1.tar.gz", hash = "sha256:1f91912c6643d2a4e49ca4ae3514f0bf3867ce948a36d99a6411b8f4755f4cf9", size = 19342, upload-time = "2026-05-16T08:18:33.538Z" }
 wheels = [
@@ -265,7 +265,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", marker = "python_full_version != '3.11.*'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6a/68/fb4fb78c9eac59d5e819108a57664737f855c5a8e9b76aec1738bb137f9e/asgiref-3.9.0.tar.gz", hash = "sha256:3dd2556d0f08c4fab8a010d9ab05ef8c34565f6bf32381d17505f7ca5b273767", size = 36772, upload-time = "2025-07-03T13:25:01.491Z" }
 wheels = [
@@ -2487,7 +2487,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.98"
+version = "0.1.99"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2817,7 +2817,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.65.0"
+version = "7.66.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },
@@ -3815,8 +3815,8 @@ name = "secretstorage"
 version = "3.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "cryptography", marker = "python_full_version < '3.13' or sys_platform != 'win32'" },
-    { name = "jeepney", marker = "python_full_version < '3.13' or sys_platform != 'win32'" },
+    { name = "cryptography" },
+    { name = "jeepney" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/53/a4/f48c9d79cb507ed1373477dbceaba7401fd8a23af63b837fa61f1dcd3691/SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77", size = 19739, upload-time = "2022-08-13T16:22:46.976Z" }
 wheels = [

From c0e05b1eba5ce1a3c109b9b0ab18c111cbc2d677 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 8 Oct 2026 14:31:59 +0000
Subject: [PATCH 009/245] Update generated references

---
 .../posthog-python-references-7.66.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.66.0.json

diff --git a/references/posthog-python-references-7.66.0.json b/references/posthog-python-references-7.66.0.json
new file mode 100644
index 000000000..2f919329f
--- /dev/null
+++ b/references/posthog-python-references-7.66.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.66.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 12adf4e4a..2f919329f 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.65.0",
+    "version": "7.66.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 9baf8a5a84545568952490ff9397f599e0d6c9b4 Mon Sep 17 00:00:00 2001
From: Hugues Pouillot <hpouillot@gmail.com>
Date: Fri, 9 Oct 2026 11:25:49 +0200
Subject: [PATCH 010/245] feat(drf): add automatic error tracking integration
 (#1036)

* feat(drf): add automatic error tracking integration

* fix(drf): align exception metadata with SDK spec

* chore(drf): type exception capture metadata

* fix(drf): honor Django request filtering

* test(drf): describe context data as properties

* feat(drf): support exception capture opt-out

* chore(drf): update public API snapshot

* fix(drf): align exception capture configuration

* test(drf): preserve omitted setting default
---
 .../django-rest-framework-error-tracking.md   |   5 +
 posthog/integrations/drf.py                   | 211 ++++++++++
 .../test/integrations/test_drf_integration.py | 388 ++++++++++++++++++
 pyproject.toml                                |   1 +
 references/public_api_snapshot.txt            |   4 +
 uv.lock                                       |  14 +
 6 files changed, 623 insertions(+)
 create mode 100644 .sampo/changesets/django-rest-framework-error-tracking.md
 create mode 100644 posthog/integrations/drf.py
 create mode 100644 posthog/test/integrations/test_drf_integration.py

diff --git a/.sampo/changesets/django-rest-framework-error-tracking.md b/.sampo/changesets/django-rest-framework-error-tracking.md
new file mode 100644
index 000000000..eb6f251b7
--- /dev/null
+++ b/.sampo/changesets/django-rest-framework-error-tracking.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add a Django REST Framework error-only exception handler that captures handled 5xx API exceptions while preserving DRF responses, leaves expected 4xx errors excluded by default, and consistently inherits Django middleware, client, request-filter, and exception-autocapture configuration.
diff --git a/posthog/integrations/drf.py b/posthog/integrations/drf.py
new file mode 100644
index 000000000..6c66d342a
--- /dev/null
+++ b/posthog/integrations/drf.py
@@ -0,0 +1,211 @@
+"""Django REST Framework exception handling integration.
+
+Django REST Framework (DRF) converts many exceptions into ``Response`` objects
+before Django's middleware can observe them. Configure this module's
+``exception_handler`` alongside :class:`PosthogContextMiddleware` to capture
+handled server errors while leaving DRF's response behavior unchanged::
+
+    REST_FRAMEWORK = {
+        "EXCEPTION_HANDLER": "posthog.integrations.drf.exception_handler",
+    }
+
+This is an error-only handler: it captures handled response errors but does
+not create the request context. Keep :class:`PosthogContextMiddleware` enabled
+to attach Django request properties and capture exceptions that DRF re-raises.
+By default, only responses with a 5xx status are captured; expected 4xx API
+errors are ignored.
+
+``capture_exceptions`` follows the Django middleware setting. An explicit
+factory argument wins over ``POSTHOG_MW_CAPTURE_EXCEPTIONS``. A boolean setting
+wins next. Setting it explicitly to ``None`` inherits the effective PostHog
+client's ``enable_exception_autocapture`` option, while an omitted or malformed
+setting preserves the legacy Django default of ``True``.
+
+Projects that already have a custom DRF exception handler can wrap it in an
+application module::
+
+    from myapp.api import existing_exception_handler
+    from posthog.integrations.drf import create_exception_handler
+
+    exception_handler = create_exception_handler(existing_exception_handler)
+
+Then point ``REST_FRAMEWORK["EXCEPTION_HANDLER"]`` at that application-level
+``exception_handler``. DRF is imported lazily, so importing the PostHog SDK does
+not require DRF to be installed.
+"""
+
+import logging
+from typing import Any, Callable, Mapping, Optional, cast
+
+from ..client import Client
+from ..contexts import _default_capture_exceptions
+from ..exception_utils import (
+    _ExceptionCaptureMetadata,
+    _capture_exception_with_metadata,
+    exception_is_already_captured as _exception_is_already_captured,
+)
+
+_logger = logging.getLogger("posthog")
+
+_CAPTURE_METADATA: _ExceptionCaptureMetadata = {
+    "level": "error",
+    "source": "django_rest_framework.exception_handler",
+    "mechanism": {"type": "middleware", "handled": True},
+}
+
+
+def _default_exception_handler(exc: Exception, context: Mapping[str, Any]) -> Any:
+    from rest_framework.views import exception_handler as drf_exception_handler
+
+    return drf_exception_handler(exc, context)
+
+
+def _configured_client(client: Optional[Client]) -> Optional[Client]:
+    if client is not None:
+        return client
+
+    try:
+        from django.conf import settings
+
+        for setting_name in ("POSTHOG_DRF_CLIENT", "POSTHOG_MW_CLIENT"):
+            configured_client = getattr(settings, setting_name, None)
+            if isinstance(configured_client, Client):
+                return configured_client
+    except Exception:
+        # Django may not be configured when a handler is created at import time.
+        pass
+
+    return None
+
+
+def _capture_exceptions_enabled(
+    configured: Optional[bool], client: Optional[Client]
+) -> bool:
+    """Resolve explicit, Django, and client exception-capture configuration."""
+    if configured is not None:
+        return configured
+
+    try:
+        from django.conf import settings
+
+        if not hasattr(settings, "POSTHOG_MW_CAPTURE_EXCEPTIONS"):
+            return True
+        django_setting = settings.POSTHOG_MW_CAPTURE_EXCEPTIONS
+    except Exception:
+        return True
+
+    if isinstance(django_setting, bool):
+        return django_setting
+    if django_setting is not None:
+        return True
+
+    try:
+        client_default = _default_capture_exceptions(client)
+    except Exception:
+        return True
+    return client_default if isinstance(client_default, bool) else True
+
+
+def _passes_django_request_filter(context: Mapping[str, Any]) -> bool:
+    """Apply the Django middleware request filter to the underlying request."""
+    try:
+        from django.conf import settings
+
+        request_filter = getattr(settings, "POSTHOG_MW_REQUEST_FILTER", None)
+    except Exception:
+        return True
+
+    request = context.get("request")
+    if not callable(request_filter) or request is None:
+        return True
+
+    # DRF wraps Django's HttpRequest. Pass the same object that
+    # PosthogContextMiddleware evaluates so filters behave consistently.
+    django_request = getattr(request, "_request", request)
+    return bool(request_filter(django_request))
+
+
+def _capture_exception(client: Optional[Client], exc: Exception) -> None:
+    if _exception_is_already_captured(exc):
+        return
+
+    if client is not None:
+        _capture_exception_with_metadata(client, exc, _CAPTURE_METADATA)
+    else:
+        from .. import capture_exception
+
+        cast(Any, capture_exception)(exc, _capture_metadata=_CAPTURE_METADATA)
+
+
+def create_exception_handler(
+    handler: Optional[Callable[[Exception, Mapping[str, Any]], Any]] = None,
+    *,
+    client: Optional[Client] = None,
+    capture_exceptions: Optional[bool] = None,
+    capture_4xx: bool = False,
+    exception_filter: Optional[
+        Callable[[Exception, Any, Mapping[str, Any]], bool]
+    ] = None,
+) -> Callable[[Exception, Mapping[str, Any]], Any]:
+    """Create a PostHog-instrumented DRF exception handler.
+
+    Args:
+        handler: Handler to delegate to. Defaults to DRF's standard exception
+            handler. Its return value and raised exceptions are preserved.
+        client: Optional PostHog client. Client precedence is this argument,
+            the legacy ``POSTHOG_DRF_CLIENT`` alias, ``POSTHOG_MW_CLIENT``, then
+            the global PostHog client.
+        capture_exceptions: Whether to capture handled DRF exceptions. An
+            explicit value takes precedence over ``POSTHOG_MW_CAPTURE_EXCEPTIONS``.
+            A boolean setting is used directly; an explicit ``None`` setting
+            inherits the effective client's ``enable_exception_autocapture``.
+            An omitted or malformed setting preserves the legacy ``True`` default.
+        capture_4xx: Also capture handled 4xx responses. Disabled by default to
+            avoid reporting expected API errors.
+        exception_filter: Optional final filter called with ``(exception,
+            response, context)``. Returning ``False`` suppresses capture.
+
+    When ``POSTHOG_MW_REQUEST_FILTER`` is configured, it is also applied to the
+    underlying Django request before capture so handled errors cannot bypass the
+    middleware's per-request exclusion.
+
+    The delegated handler is called first. A ``None`` response is never
+    captured here because DRF will re-raise that exception, allowing Django's
+    middleware to capture it as unhandled.
+    """
+    delegate = handler or _default_exception_handler
+
+    def posthog_exception_handler(exc: Exception, context: Mapping[str, Any]) -> Any:
+        response = delegate(exc, context)
+        if response is None:
+            return None
+        resolved_client = _configured_client(client)
+        if not _capture_exceptions_enabled(capture_exceptions, resolved_client):
+            return response
+
+        try:
+            status_code = int(response.status_code)
+            should_capture = status_code >= 500 or (
+                capture_4xx and 400 <= status_code < 500
+            )
+            if should_capture:
+                should_capture = _passes_django_request_filter(context)
+            if should_capture and exception_filter is not None:
+                should_capture = bool(exception_filter(exc, response, context))
+            if should_capture:
+                _capture_exception(resolved_client, exc)
+        except Exception:
+            # Error tracking must never alter DRF's exception response.
+            _logger.exception("Failed to capture Django REST Framework exception")
+
+        return response
+
+    return posthog_exception_handler
+
+
+def exception_handler(exc: Exception, context: Mapping[str, Any]) -> Any:
+    """Capture handled DRF 5xx exceptions using DRF's default handler."""
+    return _DEFAULT_EXCEPTION_HANDLER(exc, context)
+
+
+_DEFAULT_EXCEPTION_HANDLER = create_exception_handler()
diff --git a/posthog/test/integrations/test_drf_integration.py b/posthog/test/integrations/test_drf_integration.py
new file mode 100644
index 000000000..154d81517
--- /dev/null
+++ b/posthog/test/integrations/test_drf_integration.py
@@ -0,0 +1,388 @@
+import builtins
+import unittest
+from unittest.mock import Mock, patch
+
+import django
+import posthog
+from django.conf import settings
+from django.test import override_settings
+
+if not settings.configured:
+    settings.configure(
+        DEBUG=True,
+        SECRET_KEY="test-secret-key",
+        INSTALLED_APPS=[],
+        MIDDLEWARE=[],
+    )
+    django.setup()
+
+from rest_framework.exceptions import APIException, ValidationError
+from rest_framework.response import Response
+
+from posthog.client import Client
+from posthog.contexts import (
+    get_tags as get_context_properties,
+    new_context,
+    tag as set_context_property,
+)
+from posthog.integrations.drf import create_exception_handler, exception_handler
+
+
+class ServiceUnavailable(APIException):
+    status_code = 503
+    default_detail = "Service unavailable"
+
+
+class TestDjangoRestFrameworkIntegration(unittest.TestCase):
+    def test_default_handler_captures_5xx_with_canonical_metadata(self):
+        client = Mock()
+        handler = create_exception_handler(client=client)
+        exception = ServiceUnavailable()
+
+        response = handler(exception, {})
+
+        self.assertEqual(response.status_code, 503)
+        client.capture_exception.assert_called_once_with(
+            exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "django_rest_framework.exception_handler",
+                "mechanism": {
+                    "type": "middleware",
+                    "handled": True,
+                },
+            },
+        )
+
+    def test_default_handler_does_not_capture_expected_4xx(self):
+        client = Mock()
+        handler = create_exception_handler(client=client)
+        exception = ValidationError({"name": ["This field is required."]})
+
+        response = handler(exception, {})
+
+        self.assertEqual(response.status_code, 400)
+        client.capture_exception.assert_not_called()
+
+    def test_capture_4xx_is_opt_in(self):
+        client = Mock()
+        handler = create_exception_handler(client=client, capture_4xx=True)
+        exception = ValidationError("Invalid input")
+
+        response = handler(exception, {})
+
+        self.assertEqual(response.status_code, 400)
+        client.capture_exception.assert_called_once()
+
+    def test_unhandled_exception_is_left_for_django_middleware(self):
+        client = Mock()
+        handler = create_exception_handler(client=client)
+        exception = RuntimeError("unhandled")
+
+        response = handler(exception, {})
+
+        self.assertIsNone(response)
+        client.capture_exception.assert_not_called()
+
+    def test_custom_handler_response_and_context_are_preserved(self):
+        client = Mock()
+        response = Response({"detail": "custom"}, status=502)
+        delegate = Mock(return_value=response)
+        handler = create_exception_handler(delegate, client=client)
+        exception = RuntimeError("upstream failed")
+        context = {"view": object(), "request": object()}
+
+        returned_response = handler(exception, context)
+
+        self.assertIs(returned_response, response)
+        delegate.assert_called_once_with(exception, context)
+        client.capture_exception.assert_called_once()
+
+    def test_custom_handler_exception_is_preserved(self):
+        client = Mock()
+        handler_error = LookupError("handler failed")
+        delegate = Mock(side_effect=handler_error)
+        handler = create_exception_handler(delegate, client=client)
+
+        with self.assertRaisesRegex(LookupError, "handler failed"):
+            handler(RuntimeError("view failed"), {})
+
+        client.capture_exception.assert_not_called()
+
+    def test_explicit_capture_opt_out_preserves_response_without_running_filters(self):
+        client = Mock()
+        response = Response({"detail": "unavailable"}, status=503)
+        delegate = Mock(return_value=response)
+        exception_filter = Mock(return_value=True)
+        request_filter = Mock(return_value=True)
+        handler = create_exception_handler(
+            delegate,
+            client=client,
+            capture_exceptions=False,
+            exception_filter=exception_filter,
+        )
+        exception = RuntimeError("upstream failed")
+        context = {"request": object()}
+
+        with override_settings(POSTHOG_MW_REQUEST_FILTER=request_filter):
+            returned_response = handler(exception, context)
+
+        self.assertIs(returned_response, response)
+        delegate.assert_called_once_with(exception, context)
+        request_filter.assert_not_called()
+        exception_filter.assert_not_called()
+        client.capture_exception.assert_not_called()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=False)
+    def test_module_handler_inherits_django_capture_opt_out(self):
+        exception = ServiceUnavailable()
+
+        with patch("posthog.capture_exception") as capture_exception:
+            response = exception_handler(exception, {})
+
+        self.assertEqual(response.status_code, 503)
+        capture_exception.assert_not_called()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=False)
+    def test_explicit_capture_setting_overrides_django_opt_out(self):
+        client = Mock()
+        handler = create_exception_handler(client=client, capture_exceptions=True)
+        exception = ServiceUnavailable()
+
+        response = handler(exception, {})
+
+        self.assertEqual(response.status_code, 503)
+        client.capture_exception.assert_called_once()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None)
+    def test_none_django_setting_inherits_explicit_client_default(self):
+        for enabled in (False, True):
+            with self.subTest(enable_exception_autocapture=enabled):
+                client = Mock(spec=Client)
+                client.enable_exception_autocapture = enabled
+                handler = create_exception_handler(client=client)
+
+                response = handler(ServiceUnavailable(), {})
+
+                self.assertEqual(response.status_code, 503)
+                if enabled:
+                    client.capture_exception.assert_called_once()
+                else:
+                    client.capture_exception.assert_not_called()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None)
+    def test_none_django_setting_inherits_configured_client_default(self):
+        drf_client = Mock(spec=Client)
+        drf_client.enable_exception_autocapture = False
+        middleware_client = Mock(spec=Client)
+        middleware_client.enable_exception_autocapture = True
+
+        with override_settings(
+            POSTHOG_DRF_CLIENT=drf_client,
+            POSTHOG_MW_CLIENT=middleware_client,
+        ):
+            response = exception_handler(ServiceUnavailable(), {})
+
+        self.assertEqual(response.status_code, 503)
+        drf_client.capture_exception.assert_not_called()
+        middleware_client.capture_exception.assert_not_called()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None)
+    def test_none_django_setting_inherits_global_client_default(self):
+        original_default_client = posthog.default_client
+
+        try:
+            for enabled in (False, True):
+                with self.subTest(enable_exception_autocapture=enabled):
+                    global_client = Mock(spec=Client)
+                    global_client.enable_exception_autocapture = enabled
+                    posthog.default_client = global_client
+
+                    with patch("posthog.capture_exception") as capture_exception:
+                        response = exception_handler(ServiceUnavailable(), {})
+
+                    self.assertEqual(response.status_code, 503)
+                    if enabled:
+                        capture_exception.assert_called_once()
+                    else:
+                        capture_exception.assert_not_called()
+        finally:
+            posthog.default_client = original_default_client
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None)
+    def test_explicit_capture_setting_overrides_client_default(self):
+        client = Mock(spec=Client)
+        client.enable_exception_autocapture = False
+        handler = create_exception_handler(client=client, capture_exceptions=True)
+
+        response = handler(ServiceUnavailable(), {})
+
+        self.assertEqual(response.status_code, 503)
+        client.capture_exception.assert_called_once()
+
+    def test_omitted_django_capture_setting_preserves_legacy_default(self):
+        self.assertFalse(hasattr(settings, "POSTHOG_MW_CAPTURE_EXCEPTIONS"))
+        original_default_client = posthog.default_client
+        global_client = Mock(spec=Client)
+        global_client.enable_exception_autocapture = False
+        posthog.default_client = global_client
+
+        try:
+            with patch("posthog.capture_exception") as capture_exception:
+                response = exception_handler(ServiceUnavailable(), {})
+        finally:
+            posthog.default_client = original_default_client
+
+        self.assertEqual(response.status_code, 503)
+        capture_exception.assert_called_once()
+
+    @override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS="invalid")
+    def test_malformed_django_capture_setting_preserves_legacy_default(self):
+        client = Mock(spec=Client)
+        client.enable_exception_autocapture = False
+        handler = create_exception_handler(client=client)
+
+        response = handler(ServiceUnavailable(), {})
+
+        self.assertEqual(response.status_code, 503)
+        client.capture_exception.assert_called_once()
+
+    @override_settings(POSTHOG_MW_REQUEST_FILTER=lambda request: False)
+    def test_django_middleware_request_filter_suppresses_capture(self):
+        client = Mock()
+        handler = create_exception_handler(
+            lambda exc, context: Response(status=500), client=client
+        )
+        django_request = object()
+        drf_request = Mock(_request=django_request)
+
+        response = handler(RuntimeError("filtered"), {"request": drf_request})
+
+        self.assertEqual(response.status_code, 500)
+        client.capture_exception.assert_not_called()
+
+    def test_django_middleware_request_filter_receives_underlying_request(self):
+        client = Mock()
+        request_filter = Mock(return_value=True)
+        handler = create_exception_handler(
+            lambda exc, context: Response(status=500), client=client
+        )
+        django_request = object()
+        drf_request = Mock(_request=django_request)
+
+        with override_settings(POSTHOG_MW_REQUEST_FILTER=request_filter):
+            handler(RuntimeError("tracked"), {"request": drf_request})
+
+        request_filter.assert_called_once_with(django_request)
+        client.capture_exception.assert_called_once()
+
+    def test_exception_filter_can_suppress_capture(self):
+        client = Mock()
+        exception_filter = Mock(return_value=False)
+        handler = create_exception_handler(
+            lambda exc, context: Response(status=500),
+            client=client,
+            exception_filter=exception_filter,
+        )
+        exception = RuntimeError("filtered")
+        context = {"request": object()}
+
+        handler(exception, context)
+
+        exception_filter.assert_called_once()
+        client.capture_exception.assert_not_called()
+
+    def test_already_captured_exception_is_not_captured_twice(self):
+        client = Mock()
+        handler = create_exception_handler(
+            lambda exc, context: Response(status=500), client=client
+        )
+        exception = RuntimeError("already captured")
+        setattr(exception, "__posthog_exception_captured", True)
+
+        handler(exception, {})
+
+        client.capture_exception.assert_not_called()
+
+    def test_capture_exclusion_preserves_existing_django_context(self):
+        observed_properties = []
+        client = Mock()
+
+        def delegate(exc, context):
+            observed_properties.append(get_context_properties())
+            return Response(status=503)
+
+        handler = create_exception_handler(
+            delegate, client=client, capture_exceptions=False
+        )
+
+        with new_context():
+            set_context_property("$request_path", "/api/widgets")
+            response = handler(RuntimeError("excluded"), {})
+
+        self.assertEqual(response.status_code, 503)
+        self.assertEqual(observed_properties, [{"$request_path": "/api/widgets"}])
+        client.capture_exception.assert_not_called()
+
+    def test_capture_includes_existing_django_request_properties(self):
+        observed_properties = []
+        client = Mock()
+
+        def capture_exception(*args, **kwargs):
+            observed_properties.append(get_context_properties())
+
+        client.capture_exception.side_effect = capture_exception
+        handler = create_exception_handler(
+            lambda exc, context: Response(status=500), client=client
+        )
+
+        with new_context():
+            set_context_property("$request_path", "/api/widgets")
+            handler(RuntimeError("failed"), {})
+
+        self.assertEqual(observed_properties, [{"$request_path": "/api/widgets"}])
+
+    def test_capture_failure_does_not_change_response(self):
+        client = Mock()
+        client.capture_exception.side_effect = RuntimeError("capture failed")
+        response = Response(status=500)
+        handler = create_exception_handler(lambda exc, context: response, client=client)
+
+        with self.assertLogs("posthog", level="ERROR"):
+            returned_response = handler(RuntimeError("view failed"), {})
+
+        self.assertIs(returned_response, response)
+
+    def test_module_handler_uses_global_client(self):
+        exception = ServiceUnavailable()
+
+        with patch("posthog.capture_exception") as capture_exception:
+            response = exception_handler(exception, {})
+
+        self.assertEqual(response.status_code, 503)
+        capture_exception.assert_called_once_with(
+            exception,
+            _capture_metadata={
+                "level": "error",
+                "source": "django_rest_framework.exception_handler",
+                "mechanism": {
+                    "type": "middleware",
+                    "handled": True,
+                },
+            },
+        )
+
+    def test_importing_module_does_not_import_drf(self):
+        real_import = builtins.__import__
+
+        def guarded_import(name, *args, **kwargs):
+            if name == "rest_framework" or name.startswith("rest_framework."):
+                raise AssertionError("DRF imported eagerly")
+            return real_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=guarded_import):
+            # Reloading executes all module-level imports and factory setup.
+            import importlib
+            import posthog.integrations.drf as drf_integration
+
+            importlib.reload(drf_integration)
diff --git a/pyproject.toml b/pyproject.toml
index f4a0a31ab..251acd35d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -78,6 +78,7 @@ test = [
     "pytest-asyncio",
     "jsonschema>=4.0",
     "django>=5.2.15,<6.0",
+    "djangorestframework>=3.15,<4",
     "openai-agents>=0.18",
     "anthropic>=0.72",
     "langgraph>=1.0",
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 32f085b62..956efda25 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -338,6 +338,7 @@ alias posthog.integrations.asgi.Client -> posthog.client.Client
 alias posthog.integrations.asgi.contexts -> posthog.contexts
 alias posthog.integrations.django.Client -> posthog.client.Client
 alias posthog.integrations.django.contexts -> posthog.contexts
+alias posthog.integrations.drf.Client -> posthog.client.Client
 alias posthog.mcp.CaptureEventData -> posthog.mcp.types.CaptureEventData
 alias posthog.mcp.CollectFeedbackOptions -> posthog.mcp.types.CollectFeedbackOptions
 alias posthog.mcp.FeedbackReport -> posthog.mcp.types.FeedbackReport
@@ -1418,6 +1419,8 @@ function posthog.get_tags() -> Dict[str, Any]
 function posthog.group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
 function posthog.identify_context(distinct_id: str)
 function posthog.integrations.django.markcoroutinefunction(func)
+function posthog.integrations.drf.create_exception_handler(handler: Optional[Callable[[Exception, Mapping[str, Any]], Any]] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, capture_4xx: bool = False, exception_filter: Optional[Callable[[Exception, Any, Mapping[str, Any]], bool]] = None) -> Callable[[Exception, Mapping[str, Any]], Any]
+function posthog.integrations.drf.exception_handler(exc: Exception, context: Mapping[str, Any]) -> Any
 function posthog.join() -> None
 function posthog.load_feature_flags()
 function posthog.mcp.asgi.autowire_stateless_mint(server: Any) -> None
@@ -1793,6 +1796,7 @@ module posthog.integrations
 module posthog.integrations.asgi
 module posthog.integrations.celery
 module posthog.integrations.django
+module posthog.integrations.drf
 module posthog.integrations.flask
 module posthog.mcp
 module posthog.mcp.asgi
diff --git a/uv.lock b/uv.lock
index 406e0e5ed..5a1db59a1 100644
--- a/uv.lock
+++ b/uv.lock
@@ -830,6 +830,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/82/9fab66569b3e682205b52c2b203058a816c0755bc54e2adcd5d3f6018c43/django_stubs_ext-5.2.1-py3-none-any.whl", hash = "sha256:98fb0646f1a1ef07708eec5f6f7d27523f12c0c8714abae8db981571ff957588", size = 9153, upload-time = "2025-06-17T18:06:57.986Z" },
 ]
 
+[[package]]
+name = "djangorestframework"
+version = "3.18.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "django" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/2e/b3ce9d449b1ed9f9dd74fb7dfbc5f20860d5f40c2b4b10a2c3eabd8ff579/djangorestframework-3.18.1.tar.gz", hash = "sha256:605d79fa2ec2f02905492e5ea13d903c2d842d0b4c915a57f7bf02ab9f3c91dd", size = 915653, upload-time = "2026-09-07T18:04:08.288Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/83/5ed615e47339d8e65f62eb1a8133f8f046492eb3a25ad40d90acb9a208b3/djangorestframework-3.18.1-py3-none-any.whl", hash = "sha256:f1409d698967aaf82d5d98d76b549c8fba8bd92ebd0d83d24454508f72168dc2", size = 901373, upload-time = "2026-09-07T18:04:06.237Z" },
+]
+
 [[package]]
 name = "dnspython"
 version = "2.8.0"
@@ -2860,6 +2872,7 @@ test = [
     { name = "claude-agent-sdk" },
     { name = "coverage" },
     { name = "django" },
+    { name = "djangorestframework" },
     { name = "fastmcp" },
     { name = "flask" },
     { name = "freezegun" },
@@ -2906,6 +2919,7 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },

From a655c8ba25428c57a17cf38cc99bbf4987f142bf Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 09:32:12 +0000
Subject: [PATCH 011/245] chore: Release v7.67.0 [skip ci]

---
 .sampo/changesets/django-rest-framework-error-tracking.md | 5 -----
 openfeature-provider/CHANGELOG.md                         | 6 ++++++
 openfeature-provider/pyproject.toml                       | 2 +-
 posthog/CHANGELOG.md                                      | 6 ++++++
 posthog/version.py                                        | 2 +-
 pyproject.toml                                            | 2 +-
 uv.lock                                                   | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/django-rest-framework-error-tracking.md

diff --git a/.sampo/changesets/django-rest-framework-error-tracking.md b/.sampo/changesets/django-rest-framework-error-tracking.md
deleted file mode 100644
index eb6f251b7..000000000
--- a/.sampo/changesets/django-rest-framework-error-tracking.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add a Django REST Framework error-only exception handler that captures handled 5xx API exceptions while preserving DRF responses, leaves expected 4xx errors excluded by default, and consistently inherits Django middleware, client, request-filter, and exception-autocapture configuration.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 6f493d380..4ad8ab721 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.100 — 2026-10-09
+
+### Patch changes
+
+- Updated dependencies: posthog@7.67.0
+
 ## 0.1.99 — 2026-10-08
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index a85b9e803..0d92dfe66 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.99"
+version = "0.1.100"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 8033924e7..e541aafb1 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.67.0 — 2026-10-09
+
+### Minor changes
+
+- [9baf8a5](https://github.com/posthog/posthog-python/commit/9baf8a5a84545568952490ff9397f599e0d6c9b4) Add a Django REST Framework error-only exception handler that captures handled 5xx API exceptions while preserving DRF responses, leaves expected 4xx errors excluded by default, and consistently inherits Django middleware, client, request-filter, and exception-autocapture configuration. — Thanks @hpouillot!
+
 ## 7.66.0 — 2026-10-08
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index e185d24ea..3281c28e1 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.66.0"
+VERSION = "7.67.0"
diff --git a/pyproject.toml b/pyproject.toml
index 251acd35d..e49890a12 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.66.0"
+version = "7.67.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 5a1db59a1..1eef379fc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.99"
+version = "0.1.100"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.66.0"
+version = "7.67.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 509c8525fd51b52baa0ec959abe72c35aea20219 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 09:32:18 +0000
Subject: [PATCH 012/245] Update generated references

---
 .../posthog-python-references-7.67.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.67.0.json

diff --git a/references/posthog-python-references-7.67.0.json b/references/posthog-python-references-7.67.0.json
new file mode 100644
index 000000000..600acb877
--- /dev/null
+++ b/references/posthog-python-references-7.67.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.67.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 2f919329f..600acb877 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.66.0",
+    "version": "7.67.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From a3bd254bb924322bbd48a2ee2c778fe761a7ee73 Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Mon, 12 Oct 2026 13:45:14 +0300
Subject: [PATCH 013/245] feat(mcp): set $mcp_interface on mcp analytics events
 (#1032)

feat(mcp): add interface property to server events

Generated-By: PostHog Desktop
Task-Id: 651bf7d9-01f4-4d75-8583-868e29fdd314
---
 .sampo/changesets/mcp-interface-server-events.md | 5 +++++
 posthog/mcp/_posthog_events.py                   | 7 +++++--
 posthog/mcp/constants.py                         | 1 +
 posthog/test/mcp/test_pipeline.py                | 2 ++
 references/public_api_snapshot.txt               | 1 +
 5 files changed, 14 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/mcp-interface-server-events.md

diff --git a/.sampo/changesets/mcp-interface-server-events.md b/.sampo/changesets/mcp-interface-server-events.md
new file mode 100644
index 000000000..d057795ba
--- /dev/null
+++ b/.sampo/changesets/mcp-interface-server-events.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Set `$mcp_interface` to `mcp` on events from MCP servers.
diff --git a/posthog/mcp/_posthog_events.py b/posthog/mcp/_posthog_events.py
index 90040011a..7113bd2cb 100644
--- a/posthog/mcp/_posthog_events.py
+++ b/posthog/mcp/_posthog_events.py
@@ -59,7 +59,10 @@ def build_posthog_capture_events(
 
 
 def _build_capture_event(event: Event) -> PostHogCaptureEvent:
-    properties: Dict[str, Any] = {_P.SOURCE: POSTHOG_MCP_ANALYTICS_SOURCE}
+    properties: Dict[str, Any] = {
+        _P.INTERFACE: "mcp",
+        _P.SOURCE: POSTHOG_MCP_ANALYTICS_SOURCE,
+    }
     _add_session_id(event, properties)
     _add_conversation_id(event, properties)
     _add_person_processing(event, properties)
@@ -260,7 +263,7 @@ def _add_server_build(event: Event, properties: Dict[str, Any]) -> None:
 
 
 def _build_exception_event(event: Event) -> PostHogCaptureEvent:
-    properties: Dict[str, Any] = {}
+    properties: Dict[str, Any] = {_P.INTERFACE: "mcp"}
     _add_session_id(event, properties)
     _add_conversation_id(event, properties)
     _add_person_processing(event, properties)
diff --git a/posthog/mcp/constants.py b/posthog/mcp/constants.py
index ee8cf96ae..ab5dd363e 100644
--- a/posthog/mcp/constants.py
+++ b/posthog/mcp/constants.py
@@ -84,6 +84,7 @@ class PostHogMCPAnalyticsProperty:
     FEEDBACK_TASK_COMPLETED = "$mcp_feedback_task_completed"
     FEEDBACK_TOOL = "$mcp_feedback_tool"
     FEEDBACK_TYPE = "$mcp_feedback_type"
+    INTERFACE = "$mcp_interface"
     IS_ERROR = "$mcp_is_error"
     INTENT = "$mcp_intent"
     INTENT_SOURCE = "$mcp_intent_source"
diff --git a/posthog/test/mcp/test_pipeline.py b/posthog/test/mcp/test_pipeline.py
index 81b6db644..c3e39f2cf 100644
--- a/posthog/test/mcp/test_pipeline.py
+++ b/posthog/test/mcp/test_pipeline.py
@@ -885,6 +885,7 @@ def test_build_tool_call_event_properties():
     props = capture["properties"]
     assert capture["event"] == PostHogMCPAnalyticsEvent.TOOL_CALL
     assert capture["distinct_id"] == "ses_abc"
+    assert props[PostHogMCPAnalyticsProperty.INTERFACE] == "mcp"
     assert props[PostHogMCPAnalyticsProperty.SOURCE] == POSTHOG_MCP_ANALYTICS_SOURCE
     assert props[PostHogMCPAnalyticsProperty.TOOL_NAME] == "search_events"
     assert props[PostHogMCPAnalyticsProperty.TOOL_CATEGORY] == "Logs"
@@ -912,6 +913,7 @@ def test_protocol_version_on_primary_and_exception_events():
     # Both the primary $mcp_tool_call and the $exception sibling carry it.
     assert len(captures) == 2
     for capture in captures:
+        assert capture["properties"][PostHogMCPAnalyticsProperty.INTERFACE] == "mcp"
         assert (
             capture["properties"][PostHogMCPAnalyticsProperty.PROTOCOL_VERSION]
             == "2025-06-18"
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 956efda25..413310037 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -922,6 +922,7 @@ attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.INPUT_ALIASES_USED =
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.INPUT_KEYS = '$mcp_input_keys'
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.INTENT = '$mcp_intent'
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.INTENT_SOURCE = '$mcp_intent_source'
+attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.INTERFACE = '$mcp_interface'
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.IS_ERROR = '$mcp_is_error'
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.LISTED_TOOL_NAMES = '$mcp_listed_tool_names'
 attribute posthog.mcp.constants.PostHogMCPAnalyticsProperty.LLM_MODEL = '$mcp_llm_model'

From 4ae3d26abeaae89062428f662e2817f82d77b410 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:15:31 +0000
Subject: [PATCH 014/245] chore: Release v7.67.1 [skip ci]

---
 .sampo/changesets/mcp-interface-server-events.md | 5 -----
 openfeature-provider/CHANGELOG.md                | 6 ++++++
 openfeature-provider/pyproject.toml              | 2 +-
 posthog/CHANGELOG.md                             | 6 ++++++
 posthog/version.py                               | 2 +-
 pyproject.toml                                   | 2 +-
 uv.lock                                          | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-interface-server-events.md

diff --git a/.sampo/changesets/mcp-interface-server-events.md b/.sampo/changesets/mcp-interface-server-events.md
deleted file mode 100644
index d057795ba..000000000
--- a/.sampo/changesets/mcp-interface-server-events.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Set `$mcp_interface` to `mcp` on events from MCP servers.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 4ad8ab721..0a6753f2b 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.101 — 2026-10-12
+
+### Patch changes
+
+- Updated dependencies: posthog@7.67.1
+
 ## 0.1.100 — 2026-10-09
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 0d92dfe66..b247e2d5d 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.100"
+version = "0.1.101"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index e541aafb1..ef6e6cbfe 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.67.1 — 2026-10-12
+
+### Patch changes
+
+- [a3bd254](https://github.com/posthog/posthog-python/commit/a3bd254bb924322bbd48a2ee2c778fe761a7ee73) Set `$mcp_interface` to `mcp` on events from MCP servers. — Thanks @gesh!
+
 ## 7.67.0 — 2026-10-09
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 3281c28e1..5a94dcbca 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.67.0"
+VERSION = "7.67.1"
diff --git a/pyproject.toml b/pyproject.toml
index e49890a12..c8c865481 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.67.0"
+version = "7.67.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 1eef379fc..e53f89365 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.100"
+version = "0.1.101"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.67.0"
+version = "7.67.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 492d71b4b1415a6b0de41ab461374fbb8ff7d9a7 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:15:38 +0000
Subject: [PATCH 015/245] Update generated references

---
 .../posthog-python-references-7.67.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.67.1.json

diff --git a/references/posthog-python-references-7.67.1.json b/references/posthog-python-references-7.67.1.json
new file mode 100644
index 000000000..69955559b
--- /dev/null
+++ b/references/posthog-python-references-7.67.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.67.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 600acb877..69955559b 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.67.0",
+    "version": "7.67.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 2f0d67d55b074ce29b650931bb63ffe498da80a4 Mon Sep 17 00:00:00 2001
From: Hugues Pouillot <hpouillot@gmail.com>
Date: Mon, 12 Oct 2026 16:45:26 +0200
Subject: [PATCH 016/245] feat(integrations): align request middleware
 configuration (#1040)

* Align ASGI and Flask integration defaults

* feat(integrations): align request middleware configuration
---
 .../consistent-request-integration-api.md     |   5 +
 README.md                                     |   1 +
 posthog/integrations/asgi.py                  |  22 +-
 posthog/integrations/django.py                | 156 ++++++++-----
 posthog/integrations/flask.py                 |  53 +++--
 .../integrations/test_asgi_integration.py     | 112 ++++++++-
 .../integrations/test_flask_integration.py    | 136 ++++++++++-
 posthog/test/integrations/test_middleware.py  |   9 +
 .../test/integrations/test_middleware_api.py  | 216 ++++++++++++++++++
 references/middleware_configuration.md        |  69 ++++++
 references/public_api_snapshot.txt            |  16 +-
 11 files changed, 705 insertions(+), 90 deletions(-)
 create mode 100644 .sampo/changesets/consistent-request-integration-api.md
 create mode 100644 posthog/test/integrations/test_middleware_api.py
 create mode 100644 references/middleware_configuration.md

diff --git a/.sampo/changesets/consistent-request-integration-api.md b/.sampo/changesets/consistent-request-integration-api.md
new file mode 100644
index 000000000..71ed755b0
--- /dev/null
+++ b/.sampo/changesets/consistent-request-integration-api.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Align ASGI, Flask, and Django request integration configuration. ASGI and Flask now default to inheriting the effective client's exception-autocapture setting, with explicit capture overrides and context-only operation. Flask and Django require opt-in to accept PostHog tracing identity/session headers. Django adds property-named settings and extraction methods while preserving legacy aliases and its historical capture default; setting POSTHOG_MW_CAPTURE_EXCEPTIONS to None enables client inheritance. Document client routing, request-filter semantics, and event enrichment independently of error tracking.
diff --git a/README.md b/README.md
index 364101f01..cd92d38b6 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,7 @@ SDK usage examples and code snippets live in the official documentation so they
 - [Python library docs](https://posthog.com/docs/libraries/python)
 - [Django framework docs](https://posthog.com/docs/libraries/django)
 - [Flask framework docs](https://posthog.com/docs/libraries/flask)
+- [Request integration configuration](references/middleware_configuration.md) — shared middleware options and compatibility notes
 - [OpenFeature provider docs](https://posthog.com/docs/feature-flags/installation/openfeature) — use PostHog flags through the [OpenFeature](https://openfeature.dev) Python SDK
 
 ## Contributing
diff --git a/posthog/integrations/asgi.py b/posthog/integrations/asgi.py
index b00c18c87..670be43ec 100644
--- a/posthog/integrations/asgi.py
+++ b/posthog/integrations/asgi.py
@@ -17,6 +17,11 @@
 Only HTTP and WebSocket connections are instrumented. Lifespan and custom ASGI
 scope types pass through unchanged.
 
+The request context enriches events captured by any client while the request is
+running. Passing ``client`` only selects where automatically captured exceptions
+are sent; it does not redirect application calls to ``posthog.capture`` or
+``another_client.capture``.
+
 ``X-PostHog-Distinct-ID`` and ``X-PostHog-Session-ID`` are client-controlled
 analytics context, not authentication. They are ignored by default. Set
 ``trust_tracing_headers=True`` only when deliberately accepting browser analytics
@@ -169,8 +174,12 @@ class PosthogASGIMiddleware:
 
     Args:
         app: The downstream ASGI application.
-        client: Optional PostHog client. The global client is used by default.
-        capture_exceptions: Capture exceptions escaping the downstream app.
+        client: Optional destination for automatically captured exceptions. The
+            global client is used by default. Request context still enriches events
+            captured through any client and does not redirect capture calls.
+        capture_exceptions: Capture exceptions escaping the downstream app. If
+            omitted, inherit the effective client's ``enable_exception_autocapture``
+            setting. Pass ``True`` or ``False`` to override it.
         request_filter: Optional sync or async callback receiving the ASGI scope.
             Returning ``False`` bypasses all instrumentation for that scope.
         extra_properties: Optional sync or async callback receiving the ASGI scope and
@@ -186,7 +195,7 @@ def __init__(
         self,
         app: _ASGIApp,
         client: Optional[Client] = None,
-        capture_exceptions: bool = True,
+        capture_exceptions: Optional[bool] = None,
         request_filter: Optional[_RequestFilter] = None,
         extra_properties: Optional[_ExtraProperties] = None,
         trust_tracing_headers: bool = False,
@@ -235,7 +244,12 @@ async def __call__(self, scope, receive, send) -> None:
             try:
                 await self.app(scope, receive, send)
             except Exception as exception:
-                if self.capture_exceptions:
+                capture_exceptions = (
+                    self.capture_exceptions
+                    if self.capture_exceptions is not None
+                    else contexts._default_capture_exceptions(self.client)
+                )
+                if capture_exceptions:
                     if self.client:
                         _capture_exception_with_metadata(
                             self.client, exception, _CAPTURE_METADATA
diff --git a/posthog/integrations/django.py b/posthog/integrations/django.py
index 0347c6b86..7b973c0b7 100644
--- a/posthog/integrations/django.py
+++ b/posthog/integrations/django.py
@@ -69,18 +69,26 @@ class PosthogContextMiddleware:
     - Forwarded IP address as `$ip`
     - User agent as `$user_agent`
 
-    The context will also auto-capture exceptions and send them to PostHog, unless you disable it by setting
-    `POSTHOG_MW_CAPTURE_EXCEPTIONS` to `False` in your Django settings. The exceptions are captured using the
-    global client, unless the setting `POSTHOG_MW_CLIENT` is set to a custom client instance
-
-    The middleware behaviour is customisable through 3 additional functions:
-    - `POSTHOG_MW_EXTRA_TAGS`, which is a Callable[[HttpRequest], Dict[str, Any]] expected to return a dictionary of additional tags to be added to the context.
-    - `POSTHOG_MW_REQUEST_FILTER`, which is a Callable[[HttpRequest], bool] expected to return `False` if the request should not be tracked.
-    - `POSTHOG_MW_TAG_MAP`, which is a Callable[[Dict[str, Any]], Dict[str, Any]], which you can use to modify the tags before they're added to the context.
-
-    You can use the `POSTHOG_MW_TAG_MAP` function to remove any default tags you don't want to capture, or override them with your own values.
-
-    Context tags are automatically included as properties on all events captured within a context, including exceptions.
+    Configure the integration with these Django settings:
+    - `POSTHOG_MW_CLIENT`: client used for automatic exception capture, or the global client.
+      This does not redirect events explicitly captured through other clients.
+    - `POSTHOG_MW_CAPTURE_EXCEPTIONS`: `False` enables context enrichment only;
+      `True` enables automatic exception capture; `None` inherits the effective client's
+      `enable_exception_autocapture`. When omitted, the legacy default is `True`.
+    - `POSTHOG_MW_REQUEST_FILTER`: a callback receiving the request. Returning `False`
+      disables both enrichment and automatic exception capture for that request.
+    - `POSTHOG_MW_EXTRA_PROPERTIES`: a callback returning additional event properties.
+    - `POSTHOG_MW_TRUST_TRACING_HEADERS`: accept the client-controlled PostHog identity
+      and session headers only when `True` (default: `False`). These values are analytics
+      context, never authentication or authorization. Authenticated Django user identity
+      is still available when headers are disabled.
+    - `POSTHOG_MW_PROPERTIES_MAP`: an optional callback transforming request properties.
+
+    The old `POSTHOG_MW_EXTRA_TAGS` and `POSTHOG_MW_TAG_MAP` settings remain aliases;
+    the property-named settings take precedence when both are configured.
+
+    Request properties are included on all events captured within the active context,
+    including when automatic exception capture is disabled.
     See the context documentation for more information. The extracted distinct ID and session ID,
     if found, are used to associate all events captured in the middleware context with the same distinct ID
     and session as currently active on the frontend. See the documentation for `set_context_session`
@@ -113,15 +121,16 @@ def __init__(self, get_response):
 
         from django.conf import settings
 
-        if hasattr(settings, "POSTHOG_MW_EXTRA_TAGS") and callable(
-            settings.POSTHOG_MW_EXTRA_TAGS
-        ):
-            self.extra_tags = cast(
-                "Optional[Callable[[HttpRequest], Dict[str, Any]]]",
-                settings.POSTHOG_MW_EXTRA_TAGS,
-            )
-        else:
-            self.extra_tags = None
+        extra_properties = (
+            settings.POSTHOG_MW_EXTRA_PROPERTIES
+            if hasattr(settings, "POSTHOG_MW_EXTRA_PROPERTIES")
+            else getattr(settings, "POSTHOG_MW_EXTRA_TAGS", None)
+        )
+        self.extra_properties = (
+            cast("Callable[[HttpRequest], Dict[str, Any]]", extra_properties)
+            if callable(extra_properties)
+            else None
+        )
 
         if hasattr(settings, "POSTHOG_MW_REQUEST_FILTER") and callable(
             settings.POSTHOG_MW_REQUEST_FILTER
@@ -133,22 +142,29 @@ def __init__(self, get_response):
         else:
             self.request_filter = None
 
-        if hasattr(settings, "POSTHOG_MW_TAG_MAP") and callable(
-            settings.POSTHOG_MW_TAG_MAP
-        ):
-            self.tag_map = cast(
-                "Optional[Callable[[Dict[str, Any]], Dict[str, Any]]]",
-                settings.POSTHOG_MW_TAG_MAP,
-            )
-        else:
-            self.tag_map = None
+        properties_map = (
+            settings.POSTHOG_MW_PROPERTIES_MAP
+            if hasattr(settings, "POSTHOG_MW_PROPERTIES_MAP")
+            else getattr(settings, "POSTHOG_MW_TAG_MAP", None)
+        )
+        self.properties_map = (
+            cast("Callable[[Dict[str, Any]], Dict[str, Any]]", properties_map)
+            if callable(properties_map)
+            else None
+        )
 
-        if hasattr(settings, "POSTHOG_MW_CAPTURE_EXCEPTIONS") and isinstance(
-            settings.POSTHOG_MW_CAPTURE_EXCEPTIONS, bool
-        ):
-            self.capture_exceptions = settings.POSTHOG_MW_CAPTURE_EXCEPTIONS
-        else:
-            self.capture_exceptions = True
+        capture_exceptions = getattr(settings, "POSTHOG_MW_CAPTURE_EXCEPTIONS", True)
+        self.capture_exceptions: Optional[bool] = (
+            capture_exceptions
+            if capture_exceptions is None or isinstance(capture_exceptions, bool)
+            else True
+        )
+        trust_tracing_headers = getattr(
+            settings, "POSTHOG_MW_TRUST_TRACING_HEADERS", False
+        )
+        self.trust_tracing_headers = (
+            trust_tracing_headers if isinstance(trust_tracing_headers, bool) else False
+        )
 
         if hasattr(settings, "POSTHOG_MW_CLIENT") and isinstance(
             settings.POSTHOG_MW_CLIENT, Client
@@ -157,9 +173,32 @@ def __init__(self, get_response):
         else:
             self.client = None
 
+    @property
+    def extra_tags(self):
+        """Compatibility alias for ``extra_properties``."""
+        return self.extra_properties
+
+    @extra_tags.setter
+    def extra_tags(self, callback):
+        self.extra_properties = callback
+
+    @property
+    def tag_map(self):
+        """Compatibility alias for ``properties_map``."""
+        return self.properties_map
+
+    @tag_map.setter
+    def tag_map(self, callback):
+        self.properties_map = callback
+
     def extract_tags(self, request):
         # type: (HttpRequest) -> Dict[str, Any]
-        """Extract tags from request in sync context."""
+        """Compatibility alias for ``extract_properties``."""
+        return self.extract_properties(request)
+
+    def extract_properties(self, request):
+        # type: (HttpRequest) -> Dict[str, Any]
+        """Extract event properties and identity from a synchronous request."""
         user_id, user_email = self.extract_request_user(request)
         return self._build_tags(request, user_id, user_email)
 
@@ -172,15 +211,17 @@ def _build_tags(self, request, user_id, user_email):
         """
         tags = {}
 
-        # Extract session ID from X-POSTHOG-SESSION-ID header
-        session_id = _get_sanitized_tracing_header(request, "X-POSTHOG-SESSION-ID")
+        # Client-controlled headers are analytics context, not authenticated identity.
+        session_id = None
+        distinct_id = user_id
+        if self.trust_tracing_headers:
+            session_id = _get_sanitized_tracing_header(request, "X-POSTHOG-SESSION-ID")
+            distinct_id = (
+                _get_sanitized_tracing_header(request, "X-POSTHOG-DISTINCT-ID")
+                or user_id
+            )
         if session_id:
             contexts.set_context_session(session_id)
-
-        # Extract distinct ID from X-POSTHOG-DISTINCT-ID header or request user id
-        distinct_id = (
-            _get_sanitized_tracing_header(request, "X-POSTHOG-DISTINCT-ID") or user_id
-        )
         if distinct_id:
             contexts.identify_context(distinct_id)
 
@@ -213,15 +254,14 @@ def _build_tags(self, request, user_id, user_email):
             tags["$user_agent"] = user_agent
             tags["$raw_user_agent"] = user_agent
 
-        # Apply extra tags if configured
-        if self.extra_tags:
-            extra = self.extra_tags(request)
+        # Apply application-specific properties, then the optional transform.
+        if self.extra_properties:
+            extra = self.extra_properties(request)
             if extra:
                 tags.update(extra)
 
-        # Apply tag mapping if configured
-        if self.tag_map:
-            tags = self.tag_map(tags)
+        if self.properties_map:
+            tags = self.properties_map(tags)
 
         return tags
 
@@ -232,9 +272,14 @@ def extract_request_user(self, request):
         return self._resolve_user_details(user)
 
     async def aextract_tags(self, request):
+        # type: (HttpRequest) -> Dict[str, Any]
+        """Compatibility alias for ``aextract_properties``."""
+        return await self.aextract_properties(request)
+
+    async def aextract_properties(self, request):
         # type: (HttpRequest) -> Dict[str, Any]
         """
-        Async version of extract_tags for use in async request handling.
+        Async version of extract_properties for use in async request handling.
 
         Uses await request.auser() instead of request.user to avoid
         SynchronousOnlyOperation in async context.
@@ -361,7 +406,12 @@ def process_exception(self, request, exception):
         if self.request_filter and not self.request_filter(request):
             return
 
-        if not self.capture_exceptions:
+        capture_exceptions = (
+            self.capture_exceptions
+            if self.capture_exceptions is not None
+            else contexts._default_capture_exceptions(self.client)
+        )
+        if not capture_exceptions:
             return
 
         # Context and tags already set by __call__ or __acall__
@@ -374,6 +424,6 @@ def process_exception(self, request, exception):
         if self.client:
             _capture_exception_with_metadata(self.client, exception, capture_metadata)
         else:
-            from posthog import capture_exception
+            from .. import capture_exception
 
             cast(Any, capture_exception)(exception, _capture_metadata=capture_metadata)
diff --git a/posthog/integrations/flask.py b/posthog/integrations/flask.py
index 9a4bf4305..b23b62095 100644
--- a/posthog/integrations/flask.py
+++ b/posthog/integrations/flask.py
@@ -10,6 +10,11 @@
 
     app = Flask(__name__)
     PosthogFlaskIntegration(app)
+
+The request context enriches events captured by any client while the request is
+running. Passing ``client`` only selects where automatically captured exceptions
+are sent; it does not redirect application calls to ``posthog.capture`` or
+``another_client.capture``.
 """
 
 from __future__ import annotations
@@ -100,16 +105,24 @@ class PosthogFlaskIntegration:
     Args:
         app: An optional Flask application. If omitted, call :meth:`init_app`
             later (the Flask application-factory pattern).
-        client: Optional PostHog client used to capture exceptions. The global
-            client is used by default.
+        client: Optional destination for automatically captured exceptions. The
+            global client is used by default. Request context still enriches events
+            captured through any client and does not redirect capture calls.
         capture_exceptions: Capture exceptions that reach Flask's unhandled
-            exception machinery. Defaults to ``True``.
+            exception machinery. If omitted, inherit the effective client's
+            ``enable_exception_autocapture`` setting. Pass ``True`` or ``False``
+            to override it.
         request_filter: Optional callback receiving Flask's request object. A
             false return value disables both context and exception capture for
             that request.
         extra_properties: Optional callback returning additional event properties.
             This is useful for application-specific metadata such as an authenticated
             user's role. Values should not contain secrets or request bodies.
+        trust_tracing_headers: Use client-provided PostHog distinct and session ID
+            headers as analytics context. Disabled by default because these headers
+            are not authenticated. Enable only when deliberately accepting browser
+            attribution or when a trusted upstream replaces incoming values. Never
+            use these identifiers for authorization.
 
     The integration intentionally does not capture exceptions handled by an
     application error handler, expected HTTP exceptions, request or response
@@ -123,14 +136,16 @@ def __init__(
         app: Optional[Flask] = None,
         *,
         client: Optional[Client] = None,
-        capture_exceptions: bool = True,
+        capture_exceptions: Optional[bool] = None,
         request_filter: Optional[Callable[[Request], bool]] = None,
         extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None,
+        trust_tracing_headers: bool = False,
     ) -> None:
         self.client = client
         self.capture_exceptions = capture_exceptions
         self.request_filter = request_filter
         self.extra_properties = extra_properties
+        self.trust_tracing_headers = trust_tracing_headers
 
         if app is not None:
             self.init_app(app)
@@ -175,17 +190,18 @@ def _before_request(self) -> None:
         privacy_settings.apply()
         setattr(g, _REQUEST_STATE_KEY, _RequestState(scope=scope))
 
-        session_id = _sanitize_tracing_header_value(
-            request.headers.get("X-POSTHOG-SESSION-ID")
-        )
-        if session_id:
-            contexts.set_context_session(session_id)
+        if self.trust_tracing_headers:
+            session_id = _sanitize_tracing_header_value(
+                request.headers.get("X-POSTHOG-SESSION-ID")
+            )
+            if session_id:
+                contexts.set_context_session(session_id)
 
-        distinct_id = _sanitize_tracing_header_value(
-            request.headers.get("X-POSTHOG-DISTINCT-ID")
-        )
-        if distinct_id:
-            contexts.identify_context(distinct_id)
+            distinct_id = _sanitize_tracing_header_value(
+                request.headers.get("X-POSTHOG-DISTINCT-ID")
+            )
+            if distinct_id:
+                contexts.identify_context(distinct_id)
 
         for key, value in self._request_properties(request).items():
             contexts.tag(key, value)
@@ -223,7 +239,14 @@ def _request_properties(request: Request) -> dict[str, Any]:
     def _handle_unhandled_exception(
         self, sender: Flask, exception: BaseException, **kwargs: Any
     ) -> None:
-        if not self.capture_exceptions or not self._request_is_tracked():
+        if not self._request_is_tracked():
+            return
+        capture_exceptions = (
+            self.capture_exceptions
+            if self.capture_exceptions is not None
+            else contexts._default_capture_exceptions(self.client)
+        )
+        if not capture_exceptions:
             return
 
         capture_metadata: _ExceptionCaptureMetadata = {
diff --git a/posthog/test/integrations/test_asgi_integration.py b/posthog/test/integrations/test_asgi_integration.py
index 5ddaecfa4..63ddf938e 100644
--- a/posthog/test/integrations/test_asgi_integration.py
+++ b/posthog/test/integrations/test_asgi_integration.py
@@ -2,6 +2,7 @@
 
 import pytest
 
+import posthog
 from posthog import contexts
 from posthog.client import Client
 from posthog.integrations.asgi import PosthogASGIMiddleware
@@ -152,7 +153,7 @@ async def app(scope, receive, send):
         assert contexts.get_tags()["$request_path"] == "/api/items"
         raise error
 
-    middleware = PosthogASGIMiddleware(app, client=client)
+    middleware = PosthogASGIMiddleware(app, client=client, capture_exceptions=True)
 
     with pytest.raises(RuntimeError, match="application failed") as raised:
         await middleware(http_scope(), noop_receive, noop_send)
@@ -179,9 +180,9 @@ async def app(scope, receive, send):
     try:
         with patch.object(client, "capture", return_value="event-id") as capture:
             with pytest.raises(RuntimeError, match="application failed"):
-                await PosthogASGIMiddleware(app, client=client)(
-                    http_scope(), noop_receive, noop_send
-                )
+                await PosthogASGIMiddleware(
+                    app, client=client, capture_exceptions=True
+                )(http_scope(), noop_receive, noop_send)
 
         properties = capture.call_args.kwargs["properties"]
         outermost = properties["$exception_list"][0]
@@ -206,7 +207,9 @@ async def app(scope, receive, send):
 
     with patch("posthog.capture_exception") as capture_exception:
         with pytest.raises(ValueError, match="bad request handler"):
-            await PosthogASGIMiddleware(app)(http_scope(), noop_receive, noop_send)
+            await PosthogASGIMiddleware(app, capture_exceptions=True)(
+                http_scope(), noop_receive, noop_send
+            )
 
     capture_exception.assert_called_once_with(
         error,
@@ -233,14 +236,102 @@ async def app(scope, receive, send):
     client.capture_exception.assert_not_called()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("enabled", [False, True])
+async def test_exception_capture_defaults_to_custom_client_setting(enabled):
+    client = Mock(enable_exception_autocapture=enabled)
+
+    async def app(scope, receive, send):
+        raise RuntimeError("custom default")
+
+    with pytest.raises(RuntimeError, match="custom default"):
+        await PosthogASGIMiddleware(app, client=client)(
+            http_scope(), noop_receive, noop_send
+        )
+
+    if enabled:
+        client.capture_exception.assert_called_once()
+    else:
+        client.capture_exception.assert_not_called()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("enabled", [False, True])
+@pytest.mark.parametrize("initialized", [False, True])
+async def test_exception_capture_defaults_to_global_client_setting(
+    enabled, initialized
+):
+    default_client = Mock(enable_exception_autocapture=enabled) if initialized else None
+
+    async def app(scope, receive, send):
+        raise RuntimeError("global default")
+
+    # Middleware may be registered before the global client is configured.
+    middleware = PosthogASGIMiddleware(app)
+    with (
+        patch.object(posthog, "default_client", default_client),
+        patch.object(
+            posthog,
+            "enable_exception_autocapture",
+            not enabled if initialized else enabled,
+        ),
+        patch("posthog.capture_exception") as capture_exception,
+        pytest.raises(RuntimeError, match="global default"),
+    ):
+        await middleware(http_scope(), noop_receive, noop_send)
+
+    if enabled:
+        capture_exception.assert_called_once()
+    else:
+        capture_exception.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_context_enriches_events_without_redirecting_capture_calls():
+    events = []
+
+    def record_event(event):
+        events.append(event)
+        return event
+
+    event_client = Client(
+        "event-api-key", send=False, sync_mode=True, before_send=record_event
+    )
+    exception_client = Mock(enable_exception_autocapture=False)
+
+    async def app(scope, receive, send):
+        event_client.capture(
+            "request event", distinct_id="event-user", properties={"source": "app"}
+        )
+
+    try:
+        await PosthogASGIMiddleware(
+            app,
+            client=exception_client,
+            extra_properties=lambda scope: {"tenant": "acme"},
+        )(http_scope(), noop_receive, noop_send)
+    finally:
+        event_client.shutdown()
+
+    assert len(events) == 1
+    assert events[0]["distinct_id"] == "event-user"
+    assert events[0]["properties"]["source"] == "app"
+    assert events[0]["properties"]["tenant"] == "acme"
+    assert events[0]["properties"]["$request_path"] == "/api/items"
+    assert {"tenant", "$request_path"} <= set(events[0]["properties"]["$context_tags"])
+    exception_client.capture.assert_not_called()
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize("async_filter", [False, True])
 async def test_request_filter_bypasses_all_instrumentation(async_filter):
     observed = {}
+    client = Mock()
 
     async def app(scope, receive, send):
         observed["session_id"] = contexts.get_context_session_id()
         observed["properties"] = contexts.get_tags()
+        raise RuntimeError("filtered")
 
     if async_filter:
 
@@ -254,11 +345,16 @@ def request_filter(scope):
 
     with contexts.new_context(fresh=True):
         contexts.tag("existing", True)
-        await PosthogASGIMiddleware(app, request_filter=request_filter)(
-            http_scope(), noop_receive, noop_send
-        )
+        with pytest.raises(RuntimeError, match="filtered"):
+            await PosthogASGIMiddleware(
+                app,
+                client=client,
+                capture_exceptions=True,
+                request_filter=request_filter,
+            )(http_scope(), noop_receive, noop_send)
 
     assert observed == {"session_id": None, "properties": {"existing": True}}
+    client.capture_exception.assert_not_called()
 
 
 @pytest.mark.asyncio
diff --git a/posthog/test/integrations/test_flask_integration.py b/posthog/test/integrations/test_flask_integration.py
index 4df637ff2..9ce95dd3f 100644
--- a/posthog/test/integrations/test_flask_integration.py
+++ b/posthog/test/integrations/test_flask_integration.py
@@ -5,7 +5,9 @@
 import pytest
 from flask import Flask, abort, jsonify
 
+import posthog
 from posthog import contexts
+from posthog.client import Client
 from posthog.integrations.flask import (
     PosthogFlaskIntegration,
     _sanitize_tracing_header_value,
@@ -20,7 +22,11 @@ def _app() -> Flask:
 
 def test_adds_request_context_and_restores_parent_context() -> None:
     app = _app()
-    PosthogFlaskIntegration(app, extra_properties=lambda request: {"tenant": "acme"})
+    PosthogFlaskIntegration(
+        app,
+        extra_properties=lambda request: {"tenant": "acme"},
+        trust_tracing_headers=True,
+    )
 
     @app.get("/users/<user_id>")
     def view(user_id: str):
@@ -85,7 +91,7 @@ def capture(exception, **kwargs):
         return "event-id"
 
     client.capture_exception.side_effect = capture
-    PosthogFlaskIntegration(app, client=client)
+    PosthogFlaskIntegration(app, client=client, capture_exceptions=True)
 
     @app.get("/privacy")
     def privacy_failure():
@@ -138,7 +144,7 @@ def capture(exception, **kwargs):
         return "event-id"
 
     client.capture_exception.side_effect = capture
-    PosthogFlaskIntegration(app, client=client)
+    PosthogFlaskIntegration(app, client=client, capture_exceptions=True)
     error = ValueError("view failed")
 
     @app.get("/failure")
@@ -164,7 +170,7 @@ def failure():
 
 def test_uses_global_client_when_custom_client_is_not_provided() -> None:
     app = _app()
-    PosthogFlaskIntegration(app)
+    PosthogFlaskIntegration(app, capture_exceptions=True)
     error = RuntimeError("boom")
 
     @app.get("/failure")
@@ -188,7 +194,7 @@ def failure():
 def test_does_not_capture_handled_exception_or_expected_http_error() -> None:
     app = _app()
     client = Mock()
-    PosthogFlaskIntegration(app, client=client)
+    PosthogFlaskIntegration(app, client=client, capture_exceptions=True)
 
     @app.errorhandler(ValueError)
     def handle_value_error(error):
@@ -222,12 +228,132 @@ def failure():
     client.capture_exception.assert_not_called()
 
 
+@pytest.mark.parametrize("enabled", [False, True])
+def test_exception_capture_defaults_to_custom_client_setting(enabled: bool) -> None:
+    app = _app()
+    client = Mock(enable_exception_autocapture=enabled)
+    PosthogFlaskIntegration(app, client=client)
+
+    @app.get("/failure")
+    def failure():
+        raise RuntimeError("custom default")
+
+    with pytest.raises(RuntimeError, match="custom default"):
+        app.test_client().get("/failure")
+
+    if enabled:
+        client.capture_exception.assert_called_once()
+    else:
+        client.capture_exception.assert_not_called()
+
+
+@pytest.mark.parametrize("enabled", [False, True])
+@pytest.mark.parametrize("initialized", [False, True])
+def test_exception_capture_defaults_to_global_client_setting(
+    enabled: bool, initialized: bool
+) -> None:
+    app = _app()
+    default_client = Mock(enable_exception_autocapture=enabled) if initialized else None
+
+    # App-factory setup may run before the global client is configured.
+    PosthogFlaskIntegration(app)
+
+    @app.get("/failure")
+    def failure():
+        raise RuntimeError("global default")
+
+    with (
+        patch.object(posthog, "default_client", default_client),
+        patch.object(
+            posthog,
+            "enable_exception_autocapture",
+            not enabled if initialized else enabled,
+        ),
+        patch("posthog.capture_exception") as capture_exception,
+        pytest.raises(RuntimeError, match="global default"),
+    ):
+        app.test_client().get("/failure")
+
+    if enabled:
+        capture_exception.assert_called_once()
+    else:
+        capture_exception.assert_not_called()
+
+
+def test_context_enriches_events_without_redirecting_capture_calls() -> None:
+    app = _app()
+    events = []
+
+    def record_event(event):
+        events.append(event)
+        return event
+
+    event_client = Client(
+        "event-api-key", send=False, sync_mode=True, before_send=record_event
+    )
+    exception_client = Mock(enable_exception_autocapture=False)
+    PosthogFlaskIntegration(
+        app,
+        client=exception_client,
+        extra_properties=lambda request: {"tenant": "acme"},
+    )
+
+    @app.get("/capture")
+    def capture_event():
+        event_client.capture(
+            "request event", distinct_id="event-user", properties={"source": "app"}
+        )
+        return "ok"
+
+    try:
+        assert app.test_client().get("/capture").status_code == 200
+    finally:
+        event_client.shutdown()
+
+    assert len(events) == 1
+    assert events[0]["distinct_id"] == "event-user"
+    assert events[0]["properties"]["source"] == "app"
+    assert events[0]["properties"]["tenant"] == "acme"
+    assert events[0]["properties"]["$request_path"] == "/capture"
+    assert {"tenant", "$request_path"} <= set(events[0]["properties"]["$context_tags"])
+    exception_client.capture.assert_not_called()
+
+
+def test_tracing_headers_are_ignored_by_default_and_can_be_trusted() -> None:
+    def request_identity(trust_tracing_headers: bool) -> dict:
+        app = _app()
+        PosthogFlaskIntegration(app, trust_tracing_headers=trust_tracing_headers)
+
+        @app.get("/identity")
+        def identity():
+            return jsonify(
+                distinct_id=contexts.get_context_distinct_id(),
+                session_id=contexts.get_context_session_id(),
+            )
+
+        response = app.test_client().get(
+            "/identity",
+            headers={
+                "X-PostHog-Distinct-Id": "person-1",
+                "X-PostHog-Session-Id": "session-1",
+            },
+        )
+        return response.get_json()
+
+    assert request_identity(False) == {"distinct_id": None, "session_id": None}
+    assert request_identity(True) == {
+        "distinct_id": "person-1",
+        "session_id": "session-1",
+    }
+
+
 def test_request_filter_skips_context_and_exception_capture() -> None:
     app = _app()
     client = Mock()
     PosthogFlaskIntegration(
         app,
         client=client,
+        capture_exceptions=True,
         request_filter=lambda request: request.path != "/ignored",
     )
 
diff --git a/posthog/test/integrations/test_middleware.py b/posthog/test/integrations/test_middleware.py
index c76a8779a..d58065bf3 100644
--- a/posthog/test/integrations/test_middleware.py
+++ b/posthog/test/integrations/test_middleware.py
@@ -12,6 +12,7 @@
 # Configure Django settings before importing middleware
 import django
 from django.conf import settings
+from django.test import override_settings
 
 if not settings.configured:
     settings.configure(
@@ -55,6 +56,7 @@ def create_middleware(
         tag_map=None,
         capture_exceptions=True,
         get_response=None,
+        trust_tracing_headers=True,
     ):
         """Helper to create middleware instance with mock Django settings"""
         if get_response is None:
@@ -67,6 +69,7 @@ def create_middleware(
             mock_settings.POSTHOG_MW_TAG_MAP = tag_map
             mock_settings.POSTHOG_MW_CAPTURE_EXCEPTIONS = capture_exceptions
             mock_settings.POSTHOG_MW_CLIENT = None
+            mock_settings.POSTHOG_MW_TRUST_TRACING_HEADERS = trust_tracing_headers
 
             # Make hasattr work correctly
             def mock_hasattr(obj, name):
@@ -469,6 +472,12 @@ def get_response_simulating_django(request):
 class TestPosthogContextMiddlewareAsync(unittest.TestCase):
     """Test asynchronous middleware behavior"""
 
+    def setUp(self):
+        # Header propagation tests explicitly opt in to analytics attribution.
+        configuration = override_settings(POSTHOG_MW_TRUST_TRACING_HEADERS=True)
+        configuration.enable()
+        self.addCleanup(configuration.disable)
+
     def test_async_middleware_detection(self):
         """Test that async get_response is correctly detected"""
 
diff --git a/posthog/test/integrations/test_middleware_api.py b/posthog/test/integrations/test_middleware_api.py
new file mode 100644
index 000000000..7d3ccc754
--- /dev/null
+++ b/posthog/test/integrations/test_middleware_api.py
@@ -0,0 +1,216 @@
+"""Public configuration contract for Django request enrichment."""
+
+import asyncio
+from unittest.mock import Mock, patch
+
+import pytest
+from django.conf import settings
+from django.test import override_settings
+
+from posthog import contexts
+from posthog.client import Client
+from posthog.integrations.django import PosthogContextMiddleware
+from posthog.test.integrations.test_middleware import MockRequest
+
+
+@pytest.fixture
+def client():
+    instance = Client("test-key", send=False, enable_exception_autocapture=False)
+    yield instance
+    instance.shutdown()
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("enabled", [False, True])
+@pytest.mark.parametrize("configured", [None, False, True])
+def test_capture_configuration_applies_to_context_and_exception_hook(
+    client, asynchronous, enabled, configured
+):
+    client.enable_exception_autocapture = enabled
+    error = ValueError("view failed")
+    observed = []
+
+    def view(request):
+        scope = contexts._get_current_context()
+        observed.append(scope.capture_exceptions)
+        middleware.process_exception(request, error)
+        return "response"
+
+    async def async_view(request):
+        return view(request)
+
+    with (
+        override_settings(
+            POSTHOG_MW_CLIENT=client,
+            POSTHOG_MW_CAPTURE_EXCEPTIONS=configured,
+        ),
+        patch.object(client, "capture_exception") as capture,
+    ):
+        middleware = PosthogContextMiddleware(async_view if asynchronous else view)
+        result = middleware(MockRequest())
+        assert (asyncio.run(result) if asynchronous else result) == "response"
+
+    expected = enabled if configured is None else configured
+    assert observed == [expected]
+    assert capture.call_count == int(expected)
+
+
+@pytest.mark.parametrize("enabled", [False, True])
+def test_capture_none_inherits_global_configuration(enabled):
+    with (
+        override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None),
+        patch("posthog.default_client", None),
+        patch("posthog.enable_exception_autocapture", enabled),
+        patch("posthog.capture_exception") as capture,
+    ):
+        middleware = PosthogContextMiddleware(Mock())
+        middleware.process_exception(MockRequest(), ValueError("view failed"))
+        assert capture.call_count == int(enabled)
+
+
+def test_capture_none_inherits_initialized_global_client(client):
+    with (
+        override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=None),
+        patch("posthog.default_client", client),
+        patch("posthog.enable_exception_autocapture", True),
+        patch("posthog.capture_exception") as capture,
+    ):
+        # An initialized global client's setting takes precedence over the module flag.
+        middleware = PosthogContextMiddleware(Mock())
+        middleware.process_exception(MockRequest(), ValueError("view failed"))
+        capture.assert_not_called()
+
+
+def test_omitted_capture_setting_preserves_legacy_default():
+    with override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=True):
+        del settings.POSTHOG_MW_CAPTURE_EXCEPTIONS
+        middleware = PosthogContextMiddleware(Mock())
+        assert middleware.capture_exceptions is True
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("trust", [False, True])
+def test_tracing_headers_require_opt_in_and_user_fallback(asynchronous, trust):
+    observed = {}
+
+    def view(request):
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+        observed["session_id"] = contexts.get_context_session_id()
+        return "response"
+
+    async def async_view(request):
+        return view(request)
+
+    request = MockRequest(
+        headers={
+            "X-POSTHOG-DISTINCT-ID": "browser-user",
+            "X-POSTHOG-SESSION-ID": "browser-session",
+        }
+    )
+    request.user = Mock(is_authenticated=True, pk=42, email="user@example.com")
+
+    async def auser():
+        return request.user
+
+    request.auser = auser
+    with override_settings(
+        POSTHOG_MW_CAPTURE_EXCEPTIONS=False,
+        POSTHOG_MW_TRUST_TRACING_HEADERS=trust,
+    ):
+        middleware = PosthogContextMiddleware(async_view if asynchronous else view)
+        with contexts.new_context(fresh=True, capture_exceptions=False):
+            result = middleware(request)
+            assert (asyncio.run(result) if asynchronous else result) == "response"
+
+    assert observed == {
+        "distinct_id": "browser-user" if trust else "42",
+        "session_id": "browser-session" if trust else None,
+    }
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+def test_context_only_enriches_events_without_redirecting_the_client(
+    client, asynchronous
+):
+    integration_client = Mock(spec=Client)
+    captured = []
+
+    def view(request):
+        client.capture("custom-event", properties={"tenant": "explicit"})
+        middleware.process_exception(request, ValueError("view failed"))
+        return "response"
+
+    async def async_view(request):
+        return view(request)
+
+    with (
+        override_settings(
+            POSTHOG_MW_CAPTURE_EXCEPTIONS=False,
+            POSTHOG_MW_EXTRA_PROPERTIES=lambda request: {
+                "tenant": "context",
+                "role": "admin",
+            },
+        ),
+        patch.object(
+            client,
+            "_enqueue",
+            side_effect=lambda message, *args, **kwargs: captured.append(message),
+        ),
+    ):
+        middleware = PosthogContextMiddleware(async_view if asynchronous else view)
+        middleware.client = integration_client
+        result = middleware(MockRequest(path="/checkout"))
+        assert (asyncio.run(result) if asynchronous else result) == "response"
+
+    assert captured[0]["event"] == "custom-event"
+    assert captured[0]["properties"]["$request_path"] == "/checkout"
+    assert captured[0]["properties"]["tenant"] == "explicit"
+    assert captured[0]["properties"]["role"] == "admin"
+    integration_client.capture.assert_not_called()
+    integration_client.capture_exception.assert_not_called()
+    assert contexts.get_tags() == {}
+
+
+def test_property_settings_take_precedence_over_legacy_aliases():
+    with override_settings(
+        POSTHOG_MW_EXTRA_PROPERTIES=lambda request: {"new": True},
+        POSTHOG_MW_EXTRA_TAGS=lambda request: {"old": True},
+        POSTHOG_MW_PROPERTIES_MAP=lambda properties: {**properties, "mapped": "new"},
+        POSTHOG_MW_TAG_MAP=lambda properties: {**properties, "mapped": "old"},
+    ):
+        middleware = PosthogContextMiddleware(Mock())
+        properties = middleware.extract_properties(MockRequest())
+        assert properties["new"] is True
+        assert "old" not in properties
+        assert properties["mapped"] == "new"
+        assert middleware.extra_tags is middleware.extra_properties
+        assert middleware.tag_map is middleware.properties_map
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+def test_request_filter_disables_context_and_capture(client, asynchronous):
+    properties = Mock()
+    error = ValueError("view failed")
+
+    def view(request):
+        assert contexts.get_tags() == {}
+        middleware.process_exception(request, error)
+        return "response"
+
+    async def async_view(request):
+        return view(request)
+
+    with (
+        override_settings(
+            POSTHOG_MW_CLIENT=client,
+            POSTHOG_MW_CAPTURE_EXCEPTIONS=True,
+            POSTHOG_MW_REQUEST_FILTER=lambda request: False,
+            POSTHOG_MW_EXTRA_PROPERTIES=properties,
+        ),
+        patch.object(client, "capture_exception") as capture,
+    ):
+        middleware = PosthogContextMiddleware(async_view if asynchronous else view)
+        result = middleware(MockRequest())
+        assert (asyncio.run(result) if asynchronous else result) == "response"
+        capture.assert_not_called()
+        properties.assert_not_called()
diff --git a/references/middleware_configuration.md b/references/middleware_configuration.md
new file mode 100644
index 000000000..1612117d4
--- /dev/null
+++ b/references/middleware_configuration.md
@@ -0,0 +1,69 @@
+# Request integration configuration
+
+ASGI, Flask, and Django enrich events captured during an active request with request
+properties and available identity/session context. Enrichment does not create a
+request event or redirect manually captured events to a different client.
+
+## Shared options
+
+| ASGI / Flask option | Django setting | Meaning |
+| --- | --- | --- |
+| `client` | `POSTHOG_MW_CLIENT` | Client for automatic exceptions; defaults to the global client. |
+| `capture_exceptions` | `POSTHOG_MW_CAPTURE_EXCEPTIONS` | `True`: capture automatically; `False`: context only; `None`: inherit the effective client's `enable_exception_autocapture`. |
+| `request_filter` | `POSTHOG_MW_REQUEST_FILTER` | Callback returning `False` to skip both enrichment and automatic capture for a request. |
+| `extra_properties` | `POSTHOG_MW_EXTRA_PROPERTIES` | Callback returning additional event properties. Explicit properties passed to event capture take precedence. |
+| `trust_tracing_headers` | `POSTHOG_MW_TRUST_TRACING_HEADERS` | Accept `X-PostHog-Distinct-ID` and `X-PostHog-Session-ID` only when `True`; defaults to `False`. |
+
+ASGI callbacks receive the ASGI scope and can be synchronous or asynchronous.
+Flask callbacks receive the Flask request. Django callbacks receive the Django
+`HttpRequest`.
+
+ASGI and Flask default `capture_exceptions` to `None`, so installing an integration
+alone does not enable error tracking on a client that has it disabled. Client
+inheritance is resolved when an exception occurs, so client configuration performed
+after middleware registration is respected. The flag
+controls integration-level automatic capture, not manual `capture_exception()`
+calls or other independently installed error-capture hooks.
+
+## Django compatibility
+
+Django retains its historical automatic exception capture when
+`POSTHOG_MW_CAPTURE_EXCEPTIONS` is omitted. Set it to `None` to inherit the client's
+configuration, or `False` for context-only behavior.
+
+`POSTHOG_MW_EXTRA_TAGS` remains an alias for `POSTHOG_MW_EXTRA_PROPERTIES`, and
+`POSTHOG_MW_TAG_MAP` remains an alias for `POSTHOG_MW_PROPERTIES_MAP`. The latter is
+a Django-specific callback that transforms the extracted properties. When both
+old and new settings are present, the new setting takes precedence (including
+when set to `None` to disable the callback). Existing tag-named middleware methods
+and attributes remain compatibility aliases.
+
+Tracing headers now require opt-in in Django and Flask, matching ASGI's secure
+default. Applications intentionally relying on browser-to-backend analytics
+attribution must enable the trust option. Sanitization limits malformed input;
+it does not establish authenticity. Never use these headers for authentication or
+authorization. Django can still use its authenticated request user as identity
+when tracing headers are ignored.
+
+## Django REST Framework
+
+DRF handles many exceptions before Django middleware can see them, so its
+PostHog exception handler is configured separately. It does not establish request
+context: use the Django middleware for enrichment, request properties, and header
+policy.
+
+An explicit `create_exception_handler(capture_exceptions=True/False)` overrides the
+Django setting. Otherwise the handler follows `POSTHOG_MW_CAPTURE_EXCEPTIONS`,
+including `None` for client inheritance and the omitted legacy `True` default.
+Its client precedence is explicit handler client, `POSTHOG_DRF_CLIENT` (legacy
+handler-specific setting), `POSTHOG_MW_CLIENT`, then the global client.
+The middleware request filter also applies to handled DRF errors.
+
+## Lifetime and isolation
+
+Context is read when an event is captured, before it is queued for transport.
+It does not depend on a later flush occurring inside the request. Outside the
+request scope it is restored. Background threads do not automatically inherit
+request context; async tasks follow Python's context-variable propagation rules.
+Flask isolates identity and request properties while retaining effective enclosing
+exception code-variable privacy controls.
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 413310037..f8ce5837d 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -876,17 +876,21 @@ attribute posthog.integrations.celery.PosthogCeleryIntegration.client = client
 attribute posthog.integrations.celery.PosthogCeleryIntegration.propagate_context = propagate_context
 attribute posthog.integrations.celery.PosthogCeleryIntegration.task_filter = task_filter
 attribute posthog.integrations.django.PosthogContextMiddleware.async_capable = True
-attribute posthog.integrations.django.PosthogContextMiddleware.capture_exceptions = settings.POSTHOG_MW_CAPTURE_EXCEPTIONS
+attribute posthog.integrations.django.PosthogContextMiddleware.capture_exceptions: Optional[bool] = capture_exceptions if (capture_exceptions is None or isinstance(capture_exceptions, bool)) else True
 attribute posthog.integrations.django.PosthogContextMiddleware.client = cast('Optional[Client]', settings.POSTHOG_MW_CLIENT)
-attribute posthog.integrations.django.PosthogContextMiddleware.extra_tags = cast('Optional[Callable[[HttpRequest], Dict[str, Any]]]', settings.POSTHOG_MW_EXTRA_TAGS)
+attribute posthog.integrations.django.PosthogContextMiddleware.extra_properties = cast('Callable[[HttpRequest], Dict[str, Any]]', extra_properties) if callable(extra_properties) else None
+attribute posthog.integrations.django.PosthogContextMiddleware.extra_tags
 attribute posthog.integrations.django.PosthogContextMiddleware.get_response = get_response
+attribute posthog.integrations.django.PosthogContextMiddleware.properties_map = cast('Callable[[Dict[str, Any]], Dict[str, Any]]', properties_map) if callable(properties_map) else None
 attribute posthog.integrations.django.PosthogContextMiddleware.request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
 attribute posthog.integrations.django.PosthogContextMiddleware.sync_capable = True
-attribute posthog.integrations.django.PosthogContextMiddleware.tag_map = cast('Optional[Callable[[Dict[str, Any]], Dict[str, Any]]]', settings.POSTHOG_MW_TAG_MAP)
+attribute posthog.integrations.django.PosthogContextMiddleware.tag_map
+attribute posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers = trust_tracing_headers if isinstance(trust_tracing_headers, bool) else False
 attribute posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions = capture_exceptions
 attribute posthog.integrations.flask.PosthogFlaskIntegration.client = client
 attribute posthog.integrations.flask.PosthogFlaskIntegration.extra_properties = extra_properties
 attribute posthog.integrations.flask.PosthogFlaskIntegration.request_filter = request_filter
+attribute posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers = trust_tracing_headers
 attribute posthog.is_server = True
 attribute posthog.log_captured_exceptions = False
 attribute posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware.app = app
@@ -1212,10 +1216,10 @@ class posthog.feature_flags.InconclusiveMatchError
 class posthog.feature_flags.RequiresServerEvaluation 
 class posthog.flag_definition_cache.FlagDefinitionCacheData 
 class posthog.flag_definition_cache.FlagDefinitionCacheProvider 
-class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: bool = True, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: bool = False)
+class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: bool = False)
 class posthog.integrations.celery.PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
 class posthog.integrations.django.PosthogContextMiddleware(get_response)
-class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: bool = True, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None)
+class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: bool = False)
 class posthog.mcp.McpAnalytics(key: Any)
 class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any)
 class posthog.mcp.constants.PostHogMCPAnalyticsEvent 
@@ -1681,8 +1685,10 @@ method posthog.flag_definition_cache.FlagDefinitionCacheProvider.shutdown() -> O
 method posthog.integrations.celery.PosthogCeleryIntegration.instrument() -> None
 method posthog.integrations.celery.PosthogCeleryIntegration.shutdown() -> None
 method posthog.integrations.celery.PosthogCeleryIntegration.uninstrument() -> None
+method posthog.integrations.django.PosthogContextMiddleware.aextract_properties(request)
 method posthog.integrations.django.PosthogContextMiddleware.aextract_request_user(request)
 method posthog.integrations.django.PosthogContextMiddleware.aextract_tags(request)
+method posthog.integrations.django.PosthogContextMiddleware.extract_properties(request)
 method posthog.integrations.django.PosthogContextMiddleware.extract_request_user(request)
 method posthog.integrations.django.PosthogContextMiddleware.extract_tags(request)
 method posthog.integrations.django.PosthogContextMiddleware.process_exception(request, exception)

From ad553debbff78a8713147e5a845928df1613aedc Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:47:07 +0000
Subject: [PATCH 017/245] chore: Release v7.68.0 [skip ci]

---
 .sampo/changesets/consistent-request-integration-api.md | 5 -----
 openfeature-provider/CHANGELOG.md                       | 6 ++++++
 openfeature-provider/pyproject.toml                     | 2 +-
 posthog/CHANGELOG.md                                    | 6 ++++++
 posthog/version.py                                      | 2 +-
 pyproject.toml                                          | 2 +-
 uv.lock                                                 | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/consistent-request-integration-api.md

diff --git a/.sampo/changesets/consistent-request-integration-api.md b/.sampo/changesets/consistent-request-integration-api.md
deleted file mode 100644
index 71ed755b0..000000000
--- a/.sampo/changesets/consistent-request-integration-api.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Align ASGI, Flask, and Django request integration configuration. ASGI and Flask now default to inheriting the effective client's exception-autocapture setting, with explicit capture overrides and context-only operation. Flask and Django require opt-in to accept PostHog tracing identity/session headers. Django adds property-named settings and extraction methods while preserving legacy aliases and its historical capture default; setting POSTHOG_MW_CAPTURE_EXCEPTIONS to None enables client inheritance. Document client routing, request-filter semantics, and event enrichment independently of error tracking.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 0a6753f2b..1f1a08ffb 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.102 — 2026-10-12
+
+### Patch changes
+
+- Updated dependencies: posthog@7.68.0
+
 ## 0.1.101 — 2026-10-12
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index b247e2d5d..5a29d65ba 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.101"
+version = "0.1.102"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index ef6e6cbfe..64968df2d 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.68.0 — 2026-10-12
+
+### Minor changes
+
+- [2f0d67d](https://github.com/posthog/posthog-python/commit/2f0d67d55b074ce29b650931bb63ffe498da80a4) Align ASGI, Flask, and Django request integration configuration. ASGI and Flask now default to inheriting the effective client's exception-autocapture setting, with explicit capture overrides and context-only operation. Flask and Django require opt-in to accept PostHog tracing identity/session headers. Django adds property-named settings and extraction methods while preserving legacy aliases and its historical capture default; setting POSTHOG_MW_CAPTURE_EXCEPTIONS to None enables client inheritance. Document client routing, request-filter semantics, and event enrichment independently of error tracking. — Thanks @hpouillot!
+
 ## 7.67.1 — 2026-10-12
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 5a94dcbca..af1970c85 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.67.1"
+VERSION = "7.68.0"
diff --git a/pyproject.toml b/pyproject.toml
index c8c865481..3cc3c845b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.67.1"
+version = "7.68.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index e53f89365..94bba9516 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.101"
+version = "0.1.102"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.67.1"
+version = "7.68.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 90f8d6910a54fb9a009f78ecc760811885e32638 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:47:13 +0000
Subject: [PATCH 018/245] Update generated references

---
 .../posthog-python-references-7.68.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.68.0.json

diff --git a/references/posthog-python-references-7.68.0.json b/references/posthog-python-references-7.68.0.json
new file mode 100644
index 000000000..ef12885a8
--- /dev/null
+++ b/references/posthog-python-references-7.68.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.68.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 69955559b..ef12885a8 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.67.1",
+    "version": "7.68.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From ee686ffb0593fa1adfd1f2fa4bcc146270d4f07d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 10:21:20 -0700
Subject: [PATCH 019/245] chore(deps): bump the uv group across 2 directories
 with 3 updates (#1042)

Bumps the uv group with 1 update in the /examples/example-ai-llamaindex directory: [banks](https://github.com/masci/banks).
Bumps the uv group with 2 updates in the /examples/example-ai-pydantic-ai directory: [pydantic-ai](https://github.com/pydantic/pydantic-ai) and [pydantic-ai-slim](https://github.com/pydantic/pydantic-ai).


Updates `banks` from 2.4.5 to 2.5.1
- [Release notes](https://github.com/masci/banks/releases)
- [Commits](https://github.com/masci/banks/compare/v2.4.5...v2.5.1)

Updates `pydantic-ai` from 1.102.0 to 1.107.7
- [Release notes](https://github.com/pydantic/pydantic-ai/releases)
- [Changelog](https://github.com/pydantic/pydantic-ai/blob/main/docs/changelog.md)
- [Commits](https://github.com/pydantic/pydantic-ai/compare/v1.102.0...v1.107.7)

Updates `pydantic-ai-slim` from 1.102.0 to 1.107.7
- [Release notes](https://github.com/pydantic/pydantic-ai/releases)
- [Changelog](https://github.com/pydantic/pydantic-ai/blob/main/docs/changelog.md)
- [Commits](https://github.com/pydantic/pydantic-ai/compare/v1.102.0...v1.107.7)

---
updated-dependencies:
- dependency-name: banks
  dependency-version: 2.5.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: pydantic-ai
  dependency-version: 1.107.7
  dependency-type: direct:production
  dependency-group: uv
- dependency-name: pydantic-ai-slim
  dependency-version: 1.107.7
  dependency-type: indirect
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-crewai/uv.lock            |   6 +-
 examples/example-ai-dspy/uv.lock              |   6 +-
 examples/example-ai-llamaindex/uv.lock        |  11 +-
 .../example-ai-pydantic-ai/pyproject.toml     |   2 +-
 examples/example-ai-pydantic-ai/uv.lock       | 103 +++++++++++++-----
 integration_tests/django5/uv.lock             |  10 +-
 6 files changed, 98 insertions(+), 40 deletions(-)

diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index 7485aa704..752884d9c 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -3216,11 +3216,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-dspy/uv.lock b/examples/example-ai-dspy/uv.lock
index 8b14811a9..164621bcb 100644
--- a/examples/example-ai-dspy/uv.lock
+++ b/examples/example-ai-dspy/uv.lock
@@ -1901,11 +1901,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index d9f12ab82..0068648e4 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -230,7 +230,7 @@ wheels = [
 
 [[package]]
 name = "banks"
-version = "2.4.5"
+version = "2.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "deprecated" },
@@ -239,10 +239,11 @@ dependencies = [
     { name = "jinja2" },
     { name = "platformdirs" },
     { name = "pydantic" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/b5/4784ee9518b97f9f69c714a4303f9a6186a7e4ff2349f89e24767e9754d9/banks-2.4.5.tar.gz", hash = "sha256:ff575732fc67d5493a73c21e0d7268bc49e86fff02b0b8735e8efb9fcb9af3a4", size = 190822, upload-time = "2026-07-07T08:14:12.055Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/92/0449c32e718c10e4af40a3e040c830a77cdaeec6e9066622ee60e4c93e6e/banks-2.5.1.tar.gz", hash = "sha256:a7ca5c250b605ae90cfd6e4ca5dd6ce2ee377d5d59021b6feba44e345910026d", size = 196398, upload-time = "2026-09-10T10:15:34.569Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/b0/4d34cb2fe538aeb6d4b0723b3339cb932120db084a5c9a3c6966a26bbe1b/banks-2.4.5-py3-none-any.whl", hash = "sha256:ac2e0091b4c79379d4773c9d04a138a0d937ee27c5803bf0142acc6d6769eea1", size = 36145, upload-time = "2026-07-07T08:14:10.974Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/6f/06c0824ee2611de47a0fc731fa57f6042d3f573025d9f504adfd65e50d51/banks-2.5.1-py3-none-any.whl", hash = "sha256:b7c91365626bab4b46197d24ce04cd69540730ed669a50a399f240318ba3dcfb", size = 39462, upload-time = "2026-09-10T10:15:35.606Z" },
 ]
 
 [[package]]
@@ -1762,7 +1763,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.66.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1786,7 +1787,9 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
diff --git a/examples/example-ai-pydantic-ai/pyproject.toml b/examples/example-ai-pydantic-ai/pyproject.toml
index e2ea7b221..e700a26bc 100644
--- a/examples/example-ai-pydantic-ai/pyproject.toml
+++ b/examples/example-ai-pydantic-ai/pyproject.toml
@@ -3,7 +3,7 @@ name = "example-ai-pydantic-ai"
 version = "0.1.0"
 requires-python = ">=3.10"
 dependencies = [
-    "pydantic-ai==1.102.0",
+    "pydantic-ai==1.107.7",
     "opentelemetry-sdk==1.39.1",
     "posthog[otel]>=7.11.0",
 ]
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index 7e0af6691..90f37651d 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -5,7 +5,8 @@ resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
     "python_full_version < '3.14' and sys_platform == 'win32'",
-    "python_full_version < '3.14' and sys_platform != 'win32'",
+    "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "(python_full_version < '3.12' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32')",
 ]
 
 [options]
@@ -761,7 +762,7 @@ dependencies = [
 requires-dist = [
     { name = "opentelemetry-sdk", specifier = "==1.39.1" },
     { name = "posthog", extras = ["otel"], directory = "../../" },
-    { name = "pydantic-ai", specifier = "==1.102.0" },
+    { name = "pydantic-ai", specifier = "==1.107.7" },
 ]
 
 [[package]]
@@ -1036,15 +1037,15 @@ wheels = [
 
 [[package]]
 name = "genai-prices"
-version = "0.0.56"
+version = "0.0.73"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx" },
+    { name = "httpx2" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/44/6b/94b3018a672c7775edfb485f0fed8f6068fba75e49b067e8a1ac5eb96764/genai_prices-0.0.56.tar.gz", hash = "sha256:ac24b16a84d0ab97539bfa48dfa4649689de8e3ce71c12ebacef29efb1998045", size = 65872, upload-time = "2026-03-20T20:33:00.732Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/0b/4b430d9c6ff0c76e42b91fc4cedff84dfbefa1a35b885fad45a22d29303f/genai_prices-0.0.73.tar.gz", hash = "sha256:ddad5b23dadd7aac8a58ab5af7506addb062114037e96427324703e50bc35077", size = 88406, upload-time = "2026-07-29T12:48:58.215Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/f6/8ef7e4c286deb2709d11ca96a5237caae3ef4876ab3c48095856cfd2df30/genai_prices-0.0.56-py3-none-any.whl", hash = "sha256:dbe86be8f3f556bed1b72209ed36851fec8b01793b3b220f42921a4e7da945f6", size = 68966, upload-time = "2026-03-20T20:33:02.555Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/85/527a729ecd58b7169430e47febdab2e3f91193d0e3f5a56d721c04525709/genai_prices-0.0.73-py3-none-any.whl", hash = "sha256:64dfbbf55df91db6b74ff2b24ac752b8154952e0aed4e62868d6cd42710bf742", size = 92507, upload-time = "2026-07-29T12:48:57.194Z" },
 ]
 
 [[package]]
@@ -1239,6 +1240,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
 ]
 
+[[package]]
+name = "httpcore2"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+    { name = "truststore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/f3/1db7aa2bc2524062192bb0e0323969492d1883152a232fe36eea65f4e35c/httpcore2-2.13.1.tar.gz", hash = "sha256:e0aa977abe17e69a3b820a24542a6fa88702676d83880b8d194dcd18408e5103", size = 68071, upload-time = "2026-09-23T07:47:22.372Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/09/ba/a4568248771ce81957bfb7cc600264a40fbcda092391ee1c415c50be4bea/httpcore2-2.13.1-py3-none-any.whl", hash = "sha256:e1e05d4f25f7d7d496bfb96748f6f4b67657b03da069b3a68c36069f3db73d0a", size = 83423, upload-time = "2026-09-23T07:47:19.365Z" },
+]
+
 [[package]]
 name = "httpx"
 version = "0.28.1"
@@ -1263,6 +1277,32 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
 ]
 
+[[package]]
+name = "httpx2"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform != 'emscripten'" },
+    { name = "httpcore2", marker = "sys_platform != 'emscripten'" },
+    { name = "httpx2-jsfetch", marker = "python_full_version >= '3.12' and sys_platform == 'emscripten'" },
+    { name = "idna" },
+    { name = "truststore", marker = "sys_platform != 'emscripten'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/44/474bef2a0e9d90f1715d32cb98b0738695ca17ba324095fb2497ed7fbd59/httpx2-2.13.1.tar.gz", hash = "sha256:e48744a19e3af5ee48313d0ce5fe941d5422fae5705ea922a4aabf94d7800dfa", size = 100405, upload-time = "2026-09-23T07:47:23.052Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/9c/6fe8931fd9f381042a9e4c7d5a7b4cbf7016b252bec0c99a49fce42c3326/httpx2-2.13.1-py3-none-any.whl", hash = "sha256:6dff50fabc270ee5fd25d845d0b078ed20564579744d6d962850975996d2f9a4", size = 95597, upload-time = "2026-09-23T07:47:20.995Z" },
+]
+
+[[package]]
+name = "httpx2-jsfetch"
+version = "1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/0e5636363151a2a1795e0a77617168b9ca438e1748ec05fc9b5687f93d64/httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60", size = 6872, upload-time = "2026-08-07T00:13:07.492Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" },
+]
+
 [[package]]
 name = "huggingface-hub"
 version = "1.7.2"
@@ -2026,7 +2066,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.66.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2050,7 +2090,9 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -2322,19 +2364,19 @@ email = [
 
 [[package]]
 name = "pydantic-ai"
-version = "1.102.0"
+version = "1.107.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic-ai-slim", extra = ["ag-ui", "anthropic", "bedrock", "cli", "cohere", "evals", "fastmcp", "google", "groq", "huggingface", "logfire", "mcp", "mistral", "openai", "retries", "spec", "temporal", "ui", "vertexai", "xai"] },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/61/a8/c6cecf03aea4ae75126069c6b0f988263d1cb18b97d6d0a6634f5e397b56/pydantic_ai-1.102.0.tar.gz", hash = "sha256:5def631d6e1c68b5e992c88da21b78377fe9262aeaf7f9ca09f67c100a9d3878", size = 17795, upload-time = "2026-05-23T01:14:30.493Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/84/1c219ab89d42a80c77d4437704bf15a8372ee0f251924d149a7baad33c22/pydantic_ai-1.107.7.tar.gz", hash = "sha256:aa5d170bfd772d0bb31609ac8b1d9b7588bffaf6643c4a7598475312ccd75c95", size = 18747, upload-time = "2026-09-30T01:14:17.459Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/57/de1ab45c2084cb2db886a09d93b005959134655f6ec348cf8a821a177b2f/pydantic_ai-1.102.0-py3-none-any.whl", hash = "sha256:bc38cf4936cf08fa3aaf9d34abf908fd73b47147768cdeb34ec3eaf43909aca8", size = 7587, upload-time = "2026-05-23T01:14:19.813Z" },
+    { url = "https://files.pythonhosted.org/packages/db/90/5cd0849fc5a2f2e72051da99cf8be126cf4da25e225b459fd2d48e708d51/pydantic_ai-1.107.7-py3-none-any.whl", hash = "sha256:ddd9b72e4e3486fc1e0cb9fe84efef46f3a5453a4861f9d07b95f401fd7a7c1a", size = 7608, upload-time = "2026-09-30T01:14:08.826Z" },
 ]
 
 [[package]]
 name = "pydantic-ai-slim"
-version = "1.102.0"
+version = "1.107.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
@@ -2346,9 +2388,9 @@ dependencies = [
     { name = "pydantic-graph" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e2/3e/14980440e8f0532535e1fbe936fec5f8d8e7bc6cafa81f6f3c51b1884fe5/pydantic_ai_slim-1.102.0.tar.gz", hash = "sha256:0b8f2b70fa2b40efcbd09d341a346934fc4e46622ae281f858c6bfd3d0d3152b", size = 739988, upload-time = "2026-05-23T01:14:32.808Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/fd/8e5a8f207d1d397eaf26d68fe16d7916c4cfadc7be0d8e9825949c8fa19c/pydantic_ai_slim-1.107.7.tar.gz", hash = "sha256:92aa6087e190017348f9b6354d30f0e67998992c0273e778930005bc31e04794", size = 800463, upload-time = "2026-09-30T01:14:19.355Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/2e/089df86adaf904dd97a1b139d29fe728af0e41430d747f5b6315df3b0c1e/pydantic_ai_slim-1.102.0-py3-none-any.whl", hash = "sha256:f9fa9c3fb58a76f85522f78d1037d201b424de46d532263ed780b3730060449f", size = 919311, upload-time = "2026-05-23T01:14:23.464Z" },
+    { url = "https://files.pythonhosted.org/packages/28/6a/bd17311a6c3cb8c241de6abf43ef2ac0b4209ad46e24ee54efda44c2812c/pydantic_ai_slim-1.107.7-py3-none-any.whl", hash = "sha256:ecc02b80dcd9a4e7182e9389d21d6e559bcc324f6793b3f7171a52fb883edb5b", size = 984364, upload-time = "2026-09-30T01:14:11.694Z" },
 ]
 
 [package.optional-dependencies]
@@ -2385,6 +2427,7 @@ groq = [
     { name = "groq" },
 ]
 huggingface = [
+    { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
     { name = "huggingface-hub" },
 ]
 logfire = [
@@ -2541,7 +2584,7 @@ wheels = [
 
 [[package]]
 name = "pydantic-evals"
-version = "1.102.0"
+version = "1.107.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -2551,14 +2594,14 @@ dependencies = [
     { name = "pyyaml" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2a/2a/2f0a18e170dc1db4b32120bea9e1162ef196c1f453db823878f5eaf7b8bb/pydantic_evals-1.102.0.tar.gz", hash = "sha256:711a6335d24a11c324e5a5c7758b12dfd77209f885ab2501d7eedb9dd5b75b18", size = 78557, upload-time = "2026-05-23T01:14:34.447Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/1b/86b66789a04ddd382647fa0383c511214f504f652872b8b744f7b5a701a4/pydantic_evals-1.107.7.tar.gz", hash = "sha256:c42e39fec380f6126604021fa7b7da3d9b20a855746d4f17e6922d19458f35f9", size = 78541, upload-time = "2026-09-30T01:14:21.15Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/fd/2281c166b2c5cedab003b12bf8a630656cb5a9bbd552e4981ee190570d15/pydantic_evals-1.102.0-py3-none-any.whl", hash = "sha256:579edd6f7056d0fe52e03c7004377a0b9c42264c60a370258235fb0750fe20a2", size = 93529, upload-time = "2026-05-23T01:14:25.559Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/fc/3508eb8a09994edae90aa43341c989aacaf69da0269fca4e1582dc037cf9/pydantic_evals-1.107.7-py3-none-any.whl", hash = "sha256:818623cf712cb4fdc1b9e132ff238a8342c58bd158de4b4f2ec1d6b6c9dee1e5", size = 93586, upload-time = "2026-09-30T01:14:13.559Z" },
 ]
 
 [[package]]
 name = "pydantic-graph"
-version = "1.102.0"
+version = "1.107.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -2566,9 +2609,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/37/4265a1a63eddf35a5aa621c9b2355525bdeae3eb59c3954b165fbfe31404/pydantic_graph-1.102.0.tar.gz", hash = "sha256:e285bd7115e4e92676eaf0a5e7e6faa64cda8c4819f67923a118c50666b909ab", size = 62584, upload-time = "2026-05-23T01:14:36.056Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/87/d7/9ec3ab42158e5317d031c915ff06450cb58103637d8c1082f6afda43c501/pydantic_graph-1.107.7.tar.gz", hash = "sha256:f58b7dfa3bf60eb7d68946e64dff2ccbb8e8c67458e957efd7d14bc9338c9400", size = 62567, upload-time = "2026-09-30T01:14:22.16Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a4/49/5597c52d50114440047dd4ce4f6505e32ee336f43267639907d1a17648ee/pydantic_graph-1.102.0-py3-none-any.whl", hash = "sha256:b1a28314adc4abca4db02cf095d064782ec5712e0847ce7a6b79a3c84bf1fc01", size = 80100, upload-time = "2026-05-23T01:14:27.583Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/bb/b7a252e6205d9321ac1ce11fa251d8a25fe27cd23e780afd899036047b8f/pydantic_graph-1.107.7-py3-none-any.whl", hash = "sha256:0a7b964d6895f80b51ebab5e77f59b500d39ca7b17095e2233861e6dfd338ec6", size = 80106, upload-time = "2026-09-30T01:14:15.065Z" },
 ]
 
 [[package]]
@@ -2646,11 +2689,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]
@@ -3319,6 +3362,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
 ]
 
+[[package]]
+name = "truststore"
+version = "0.10.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" },
+]
+
 [[package]]
 name = "typer"
 version = "0.24.1"
@@ -3659,7 +3711,7 @@ wheels = [
 
 [[package]]
 name = "xai-sdk"
-version = "1.10.0"
+version = "1.20.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -3670,10 +3722,11 @@ dependencies = [
     { name = "protobuf" },
     { name = "pydantic" },
     { name = "requests" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ac/f7/8053a41e67e3e14fb1a52afc2bef5642f9346cedc3f0594a83b6eec09e5a/xai_sdk-1.10.0.tar.gz", hash = "sha256:0ddb4def34294ba11573b3a4efdd8510456be304b175ddba96a1d687b9dea30e", size = 402806, upload-time = "2026-03-24T17:24:57.113Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/2b/a03f4a0495e279ece44920bba9da85abe15c3a14ec8eecd683608db63763/xai_sdk-1.20.0.tar.gz", hash = "sha256:ae10fd1713b20a852ffc9909d83233550a3193bd718f77a891ca1485f08e5fb3", size = 473156, upload-time = "2026-09-24T18:05:37.484Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/01/4082ae7ead2e84c22e22ef383c17f62224abbf9c6aba1f12bab3f80df148/xai_sdk-1.10.0-py3-none-any.whl", hash = "sha256:7644afe2f60311ae626fd3bb364fe135beff96b08715f430ee4a085f5542e357", size = 250708, upload-time = "2026-03-24T17:24:55.576Z" },
+    { url = "https://files.pythonhosted.org/packages/55/be/ac8c239f2a38172fb59763d6715bbf24864e24319ccdd7a09894c7644d1c/xai_sdk-1.20.0-py3-none-any.whl", hash = "sha256:cfd64983c48c78a647460a2e8ee136e6a35929249989b6c9be6387fdf86d661f", size = 281393, upload-time = "2026-09-24T18:05:35.82Z" },
 ]
 
 [[package]]
diff --git a/integration_tests/django5/uv.lock b/integration_tests/django5/uv.lock
index 66c61178e..68d85d4a7 100644
--- a/integration_tests/django5/uv.lock
+++ b/integration_tests/django5/uv.lock
@@ -251,7 +251,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.66.0"
 source = { editable = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -269,7 +269,9 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -375,11 +377,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]

From 3cc2d6468d22306897db285bf5fa291a94287e71 Mon Sep 17 00:00:00 2001
From: Daniel Visca <daniel.v@posthog.com>
Date: Tue, 13 Oct 2026 19:04:06 -0400
Subject: [PATCH 020/245] feat(metrics): attach trace exemplars to flushed
 metric series (#1057)

---
 .sampo/changesets/metrics-trace-exemplars.md |   5 +
 posthog/metrics_capture.py                   |  90 +++++++++++++
 posthog/test/test_metrics.py                 | 131 +++++++++++++++++++
 3 files changed, 226 insertions(+)
 create mode 100644 .sampo/changesets/metrics-trace-exemplars.md

diff --git a/.sampo/changesets/metrics-trace-exemplars.md b/.sampo/changesets/metrics-trace-exemplars.md
new file mode 100644
index 000000000..9617ba446
--- /dev/null
+++ b/.sampo/changesets/metrics-trace-exemplars.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+`client.metrics` now attaches a trace exemplar to each series it flushes. A sample recorded inside a sampled span (a PostHog `start_span` span, or the current OpenTelemetry span) stamps its data point with that span's trace ID, span ID, and value, so metric charts can link to a representative trace. One exemplar per series per flush window; the last sample wins.
diff --git a/posthog/metrics_capture.py b/posthog/metrics_capture.py
index 6e454842c..781aa89b3 100644
--- a/posthog/metrics_capture.py
+++ b/posthog/metrics_capture.py
@@ -12,6 +12,11 @@
 is attached: every attribute value creates a new series, and per-user series
 are the canonical metrics-cardinality explosion.
 
+A sample recorded inside a sampled span (a PostHog ``start_span`` span, or the
+current OpenTelemetry span) stamps its series with an exemplar: the trace and
+span IDs plus the value. One exemplar per series per window, last sample wins,
+so a metric point links to one representative trace at no cardinality cost.
+
 Delivery is at-least-once: a request that succeeds server-side but fails
 client-side (e.g. a read timeout) is retried with the next window, which can
 double-count that window's deltas. Failed flushes retry with exponential
@@ -37,6 +42,8 @@
 from posthog.utils import remove_trailing_slash
 from posthog.version import VERSION
 
+from .tracing._traceparent import TRACE_FLAGS_SAMPLED, parse_traceparent
+
 log = logging.getLogger("posthog")
 
 MetricAttributeValue = Union[str, int, float, bool]
@@ -74,6 +81,8 @@
 _DEFAULT_FLUSH_INTERVAL_SECONDS = 10.0
 _DEFAULT_MAX_SERIES_PER_FLUSH = 1000
 _SCOPE_NAME = "posthog-python"
+# None until the first lookup; False when opentelemetry-api is not installed.
+_otel_trace: Any = None
 
 
 def _snapshot_attribute_value(value: Any) -> Any:
@@ -135,6 +144,52 @@ def _bucket_index_for(value: float, bounds: list) -> int:
     return len(bounds)
 
 
+def _parse_sampled_traceparent(value: Any) -> Optional[tuple[str, str]]:
+    """The (trace_id, span_id) of a sampled W3C ``traceparent``, or None."""
+    context = parse_traceparent(value)
+    if context is None or context.flags != TRACE_FLAGS_SAMPLED:
+        return None
+    return context.trace_id, context.span_id
+
+
+def _otel_trace_module() -> Any:
+    global _otel_trace
+    if _otel_trace is None:
+        try:
+            from opentelemetry import trace
+
+            _otel_trace = trace
+        except ImportError:
+            _otel_trace = False
+    return _otel_trace
+
+
+def _active_trace_context(client: Any) -> Optional[tuple[str, str]]:
+    """The sampled span a sample is recorded in: PostHog's own active span first,
+    then the current OpenTelemetry span. An unsampled span is never exported, so
+    an exemplar pointing at it would link to a trace that does not exist."""
+    try:
+        get_active_span = getattr(client, "get_active_span", None)
+        span = get_active_span() if callable(get_active_span) else None
+        if span is not None:
+            # A PostHog span is active, so it is the innermost context; an
+            # unsampled one must not fall through to an outer OTel span.
+            return _parse_sampled_traceparent(span.traceparent())
+    except Exception:
+        pass
+
+    trace = _otel_trace_module()
+    if not trace:
+        return None
+    try:
+        span_context = trace.get_current_span().get_span_context()
+        if not span_context.is_valid or not span_context.trace_flags.sampled:
+            return None
+        return f"{span_context.trace_id:032x}", f"{span_context.span_id:016x}"
+    except Exception:
+        return None
+
+
 def _series_key(
     metric_type: str, name: str, unit: Optional[str], attributes: Optional[dict]
 ) -> str:
@@ -153,6 +208,24 @@ def _series_key(
     return "\x00".join((metric_type, name, unit or "", attrs_part))
 
 
+def _build_exemplars(exemplar: Optional[dict]) -> dict:
+    # Spread into the data point, so a point without an exemplar keeps its
+    # exact pre-exemplar wire shape. OTLP/JSON encodes trace and span IDs as hex.
+    if exemplar is None:
+        return {}
+    return {
+        "exemplars": [
+            {
+                "filteredAttributes": [],
+                "timeUnixNano": _ms_to_unix_nano(exemplar["time_ms"]),
+                "asDouble": exemplar["value"],
+                "traceId": exemplar["trace_id"],
+                "spanId": exemplar["span_id"],
+            }
+        ]
+    }
+
+
 class _SeriesState:
     __slots__ = (
         "name",
@@ -163,6 +236,7 @@ class _SeriesState:
         "total",
         "last",
         "hist",
+        "exemplar",
     )
 
     def __init__(
@@ -195,6 +269,7 @@ def __init__(
         self.total: Optional[float] = None
         self.last: Optional[float] = None
         self.hist: Optional[dict] = None
+        self.exemplar: Optional[dict] = None
 
 
 class PostHogMetrics:
@@ -412,6 +487,7 @@ def _capture(
             # series identity too — otherwise two indistinguishable data points emit.
             attributes = {k: v for k, v in attributes.items() if v is not None}
         key = _series_key(metric_type, name, unit, attributes)
+        trace_context = _active_trace_context(self._client)
 
         with self._lock:
             self._reset_after_fork_locked()
@@ -446,6 +522,13 @@ def _capture(
                 )
 
             self._fold(state, float(value))
+            if trace_context is not None:
+                state.exemplar = {
+                    "trace_id": trace_context[0],
+                    "span_id": trace_context[1],
+                    "value": float(value),
+                    "time_ms": int(time.time() * 1000),
+                }
             self._arm_flush_timer()
 
     def _reinit_after_fork(self) -> None:
@@ -641,6 +724,9 @@ def _merge_window_back(self, window: dict) -> None:
                 self._series[key] = old
                 continue
             current.window_start_ms = min(current.window_start_ms, old.window_start_ms)
+            # The live window's exemplar is newer; the old one only fills a gap.
+            if current.exemplar is None:
+                current.exemplar = old.exemplar
             if current.type == "count":
                 current.total = (current.total or 0.0) + (old.total or 0.0)
             elif current.type == "histogram" and old.hist:
@@ -718,6 +804,7 @@ def _build_metrics(self, window: dict) -> list:
 
             attributes = _to_otlp_key_value_list(state.attributes or {})
             start_nano = _ms_to_unix_nano(state.window_start_ms)
+            exemplars = _build_exemplars(state.exemplar)
 
             if state.type == "count":
                 metric["sum"]["dataPoints"].append(
@@ -726,6 +813,7 @@ def _build_metrics(self, window: dict) -> list:
                         "startTimeUnixNano": start_nano,
                         "timeUnixNano": now_nano,
                         "asDouble": state.total or 0.0,
+                        **exemplars,
                     }
                 )
             elif state.type == "gauge":
@@ -734,6 +822,7 @@ def _build_metrics(self, window: dict) -> list:
                         "attributes": attributes,
                         "timeUnixNano": now_nano,
                         "asDouble": state.last or 0.0,
+                        **exemplars,
                     }
                 )
             elif state.hist is not None:
@@ -751,6 +840,7 @@ def _build_metrics(self, window: dict) -> list:
                         "max": state.hist["max"],
                         "bucketCounts": state.hist["bucket_counts"],
                         "explicitBounds": DEFAULT_HISTOGRAM_BOUNDS,
+                        **exemplars,
                     }
                 )
 
diff --git a/posthog/test/test_metrics.py b/posthog/test/test_metrics.py
index 0575c2aa1..e25bb34bf 100644
--- a/posthog/test/test_metrics.py
+++ b/posthog/test/test_metrics.py
@@ -4,6 +4,8 @@
 from unittest import mock
 
 import pytest
+from opentelemetry import trace
+from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
 
 import posthog
 from posthog.client import Client
@@ -25,6 +27,21 @@ def client():
     c.metrics.reset()
 
 
+@pytest.fixture
+def traced_client():
+    # Tracing on, so start_span returns a recording span with its own span ID
+    # instead of a pass-through that echoes the parent's traceparent.
+    with mock.patch(
+        "posthog.tracing._transport._get_session", return_value=mock_session()
+    ):
+        c = Client(
+            FAKE_API_KEY, host="https://us.example.com", sync_mode=True, traces={}
+        )
+        yield c
+        c.metrics.reset()
+        c.shutdown()
+
+
 def mock_session(status_code=200):
     session = mock.Mock()
     session.post.return_value = mock.Mock(status_code=status_code)
@@ -586,6 +603,120 @@ def test_any_value_encoding_matches_js(self, client, value, expected):
         assert attr["value"] == expected
 
 
+OTEL_TRACE_ID = "4bf92f3577b34da6a3ce929d0e0e4736"
+OTEL_SPAN_ID = "00f067aa0ba902b7"
+
+
+def otel_span(sampled):
+    return NonRecordingSpan(
+        SpanContext(
+            trace_id=int(OTEL_TRACE_ID, 16),
+            span_id=int(OTEL_SPAN_ID, 16),
+            is_remote=False,
+            trace_flags=TraceFlags(
+                TraceFlags.SAMPLED if sampled else TraceFlags.DEFAULT
+            ),
+        )
+    )
+
+
+def data_points_by_type(payload):
+    points = {}
+    for metric in metrics_from(payload):
+        for kind in ("sum", "gauge", "histogram"):
+            if kind in metric:
+                points[kind] = metric[kind]["dataPoints"][0]
+    return points
+
+
+def record_one_of_each(client):
+    client.metrics.count("c", 1)
+    client.metrics.count("c", 4)
+    client.metrics.gauge("g", 7)
+    client.metrics.histogram("h", 12)
+
+
+class TestMetricsExemplars:
+    def test_sampled_otel_span_stamps_last_sample_on_every_type(self, client):
+        with trace.use_span(otel_span(sampled=True)):
+            record_one_of_each(client)
+
+        payload, _, _ = flush_and_capture(client)
+        points = data_points_by_type(payload)
+
+        for kind, value in (("sum", 4), ("gauge", 7), ("histogram", 12)):
+            (exemplar,) = points[kind]["exemplars"]
+            assert exemplar["traceId"] == OTEL_TRACE_ID
+            assert exemplar["spanId"] == OTEL_SPAN_ID
+            assert exemplar["asDouble"] == value
+            assert exemplar["timeUnixNano"].isdigit()
+
+    def test_active_posthog_span_wins_over_outer_otel_span(self, traced_client):
+        parent_trace_id, parent_span_id = "a" * 32, "b" * 16
+        with trace.use_span(otel_span(sampled=True)):
+            with traced_client.start_span(
+                "job", parent=f"00-{parent_trace_id}-{parent_span_id}-01"
+            ) as span:
+                traced_client.metrics.count("c", 1)
+                _, trace_id, span_id, _ = span.traceparent().split("-")
+
+        payload, _, _ = flush_and_capture(traced_client)
+        (exemplar,) = data_points_by_type(payload)["sum"]["exemplars"]
+        # The recording span's own ID, in the inbound trace, not the parent's.
+        assert span_id not in (parent_span_id, OTEL_SPAN_ID)
+        assert (exemplar["traceId"], exemplar["spanId"]) == (parent_trace_id, span_id)
+
+    def test_innermost_posthog_span_is_the_exemplar(self, traced_client):
+        with traced_client.start_span("request"):
+            with traced_client.start_span("db.query") as child:
+                traced_client.metrics.histogram("h", 3)
+                _, trace_id, span_id, _ = child.traceparent().split("-")
+
+        payload, _, _ = flush_and_capture(traced_client)
+        (exemplar,) = data_points_by_type(payload)["histogram"]["exemplars"]
+        assert (exemplar["traceId"], exemplar["spanId"]) == (trace_id, span_id)
+
+    @pytest.mark.parametrize("context", ["no_span", "unsampled_otel_span"])
+    def test_no_exemplar_without_a_sampled_span(self, client, context):
+        if context == "no_span":
+            record_one_of_each(client)
+        else:
+            with trace.use_span(otel_span(sampled=False)):
+                record_one_of_each(client)
+
+        payload, _, _ = flush_and_capture(client)
+        for point in data_points_by_type(payload).values():
+            assert "exemplars" not in point
+
+    def test_unsampled_posthog_span_hides_a_sampled_outer_otel_span(
+        self, traced_client
+    ):
+        with trace.use_span(otel_span(sampled=True)):
+            with traced_client.start_span(
+                "job", parent=f"00-{'a' * 32}-{'b' * 16}-00"
+            ) as span:
+                assert span.traceparent().endswith("-00")
+                record_one_of_each(traced_client)
+
+        payload, _, _ = flush_and_capture(traced_client)
+        for point in data_points_by_type(payload).values():
+            assert "exemplars" not in point
+
+    def test_failed_flush_keeps_exemplar_for_the_retry(self, client):
+        with trace.use_span(otel_span(sampled=True)):
+            client.metrics.count("c", 1)
+        with mock.patch(
+            "posthog.metrics_capture._get_session", return_value=mock_session(503)
+        ):
+            client.metrics.flush()
+        client.metrics.count("c", 2)
+
+        payload, _, _ = flush_and_capture(client)
+        point = data_points_by_type(payload)["sum"]
+        assert point["asDouble"] == 3
+        assert point["exemplars"][0]["traceId"] == OTEL_TRACE_ID
+
+
 class TestMetricsFailureHandling:
     def test_fork_drops_inherited_window_and_rearms(self, client):
         # A forked child inherits a dead timer thread and the parent's window; without the

From 653ff87684d7453ee01dd3f2f19dbf709bcf6592 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 13 Oct 2026 23:14:21 +0000
Subject: [PATCH 021/245] chore: Release v7.69.0 [skip ci]

---
 .sampo/changesets/metrics-trace-exemplars.md | 5 -----
 openfeature-provider/CHANGELOG.md            | 6 ++++++
 openfeature-provider/pyproject.toml          | 2 +-
 posthog/CHANGELOG.md                         | 6 ++++++
 posthog/version.py                           | 2 +-
 pyproject.toml                               | 2 +-
 uv.lock                                      | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/metrics-trace-exemplars.md

diff --git a/.sampo/changesets/metrics-trace-exemplars.md b/.sampo/changesets/metrics-trace-exemplars.md
deleted file mode 100644
index 9617ba446..000000000
--- a/.sampo/changesets/metrics-trace-exemplars.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-`client.metrics` now attaches a trace exemplar to each series it flushes. A sample recorded inside a sampled span (a PostHog `start_span` span, or the current OpenTelemetry span) stamps its data point with that span's trace ID, span ID, and value, so metric charts can link to a representative trace. One exemplar per series per flush window; the last sample wins.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 1f1a08ffb..a187f190f 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.103 — 2026-10-13
+
+### Patch changes
+
+- Updated dependencies: posthog@7.69.0
+
 ## 0.1.102 — 2026-10-12
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 5a29d65ba..3137266d0 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.102"
+version = "0.1.103"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 64968df2d..424723c31 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.69.0 — 2026-10-13
+
+### Minor changes
+
+- [3cc2d64](https://github.com/posthog/posthog-python/commit/3cc2d6468d22306897db285bf5fa291a94287e71) `client.metrics` now attaches a trace exemplar to each series it flushes. A sample recorded inside a sampled span (a PostHog `start_span` span, or the current OpenTelemetry span) stamps its data point with that span's trace ID, span ID, and value, so metric charts can link to a representative trace. One exemplar per series per flush window; the last sample wins. — Thanks @DanielVisca!
+
 ## 7.68.0 — 2026-10-12
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index af1970c85..fdd21fd65 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.68.0"
+VERSION = "7.69.0"
diff --git a/pyproject.toml b/pyproject.toml
index 3cc3c845b..f33639501 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.68.0"
+version = "7.69.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 94bba9516..bd828339a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.102"
+version = "0.1.103"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.68.0"
+version = "7.69.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 6f658988e5b843c03ec73287677cae0f83b391e3 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 13 Oct 2026 23:14:28 +0000
Subject: [PATCH 022/245] Update generated references

---
 .../posthog-python-references-7.69.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.69.0.json

diff --git a/references/posthog-python-references-7.69.0.json b/references/posthog-python-references-7.69.0.json
new file mode 100644
index 000000000..d407afdb1
--- /dev/null
+++ b/references/posthog-python-references-7.69.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.69.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index ef12885a8..d407afdb1 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.68.0",
+    "version": "7.69.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 69164994c920bbaf445c3a2c20b9f558f6a5a473 Mon Sep 17 00:00:00 2001
From: Carlos Marchal <carlos@posthog.com>
Date: Wed, 14 Oct 2026 18:52:19 +0200
Subject: [PATCH 023/245] feat(ai): add per-request context to span processor
 (#1060)

* feat: span processor request context

* fix: span processor review feedback

* fix: span processor review follow-ups
---
 .../span-processor-request-context.md         |   5 +
 posthog/ai/otel/_request_context.py           | 146 +++++++++
 posthog/ai/otel/exporter.py                   |   2 +
 posthog/ai/otel/processor.py                  | 106 +++++-
 posthog/test/ai/otel/test_processor.py        | 303 +++++++++++++++++-
 references/public_api_snapshot.txt            |   1 +
 6 files changed, 557 insertions(+), 6 deletions(-)
 create mode 100644 .sampo/changesets/span-processor-request-context.md
 create mode 100644 posthog/ai/otel/_request_context.py

diff --git a/.sampo/changesets/span-processor-request-context.md b/.sampo/changesets/span-processor-request-context.md
new file mode 100644
index 000000000..2d3b5f637
--- /dev/null
+++ b/.sampo/changesets/span-processor-request-context.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+`PostHogSpanProcessor` now adds the active PostHog context to the AI spans it exports: the distinct ID from `identify_context`, the session ID from `set_context_session` (sent as `$session_id`), and context tags as properties. Spans started inside `posthog.new_context()` reach PostHog under the right person, so one process can trace many users. Tags set by the request middleware (for example `email`, `$ip`, `$user_agent` and `$current_url`) now appear on AI events too. Attributes already on a span are kept, and other processors on the provider never see the context. Apps already using PostHog contexts (for example the Django, Flask or ASGI request middleware) will see their AI events attributed to the context's person after upgrading.
diff --git a/posthog/ai/otel/_request_context.py b/posthog/ai/otel/_request_context.py
new file mode 100644
index 000000000..b34bf4c61
--- /dev/null
+++ b/posthog/ai/otel/_request_context.py
@@ -0,0 +1,146 @@
+"""Captures the active PostHog context for a span and applies it to an exported copy."""
+
+import datetime
+import decimal
+import json
+import logging
+import math
+import uuid
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Sequence
+
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.util.types import AttributeValue
+
+from ...contexts import get_context_distinct_id, get_context_session_id, get_tags
+
+DISTINCT_ID_ATTRIBUTE = "posthog.distinct_id"
+SESSION_ID_ATTRIBUTE = "$session_id"
+# Ingestion prefers posthog.distinct_id, so adding the context's would override the span's explicit user.
+IDENTITY_ATTRIBUTES = (
+    DISTINCT_ID_ATTRIBUTE,
+    "user.id",
+    "ai.telemetry.metadata.posthog_distinct_id",
+    "ai.settings.context.posthog_distinct_id",
+)
+_MAX_INT64 = 2**63 - 1
+_MIN_INT64 = -(2**63)
+_PRIMITIVE_TYPES = (str, bool, int, float)
+
+log = logging.getLogger("posthog")
+
+
+@dataclass(frozen=True)
+class RequestContext:
+    distinct_id: Optional[str]
+    session_id: Optional[str]
+    tags: Dict[str, Any]
+
+
+def capture_request_context() -> Optional[RequestContext]:
+    """Snapshot the active context's distinct ID, session ID and tags, or None if all are empty."""
+    snapshot = RequestContext(
+        distinct_id=get_context_distinct_id() or None,
+        session_id=get_context_session_id() or None,
+        tags=dict(get_tags()),
+    )
+    if not (snapshot.distinct_id or snapshot.session_id or snapshot.tags):
+        return None
+    return snapshot
+
+
+def request_context_attributes(context: RequestContext) -> Dict[str, AttributeValue]:
+    """Return the snapshot as span attributes. Tags win over the context IDs."""
+    values: Dict[str, Any] = {
+        key: value
+        for key, value in (
+            (DISTINCT_ID_ATTRIBUTE, context.distinct_id),
+            (SESSION_ID_ATTRIBUTE, context.session_id),
+        )
+        if value
+    }
+    values.update(context.tags)
+
+    attributes: Dict[str, AttributeValue] = {}
+    for key, value in values.items():
+        try:
+            attribute = to_attribute_value(value)
+        except Exception:
+            log.debug("Failed to read PostHog context value %r", key, exc_info=True)
+            continue
+        if attribute is not None:
+            attributes[key] = attribute
+    return attributes
+
+
+def with_request_context(span: ReadableSpan, context: RequestContext) -> ReadableSpan:
+    """Return a copy of ``span`` with the context's values added, keeping attributes it already has."""
+    own = span.attributes or {}
+    has_identity = any(key in own for key in IDENTITY_ATTRIBUTES)
+    extra = {
+        key: value
+        for key, value in request_context_attributes(context).items()
+        if key not in own and not (has_identity and key == DISTINCT_ID_ATTRIBUTE)
+    }
+    if not extra:
+        return span
+    return ReadableSpan(
+        name=span.name,
+        context=span.get_span_context(),
+        parent=span.parent,
+        resource=span.resource,
+        attributes={**own, **extra},
+        events=span.events,
+        links=span.links,
+        kind=span.kind,
+        status=span.status,
+        start_time=span.start_time,
+        end_time=span.end_time,
+        instrumentation_scope=span.instrumentation_scope,
+    )
+
+
+def to_attribute_value(value: Any) -> Optional[AttributeValue]:
+    """Return ``value`` as an OpenTelemetry attribute value, JSON-encoding anything OTel can't hold."""
+    if value is None or (isinstance(value, str) and not value):
+        return None
+    if isinstance(value, float) and not math.isfinite(value):
+        return None
+    if _is_out_of_int64_range(value):
+        return str(value)
+    if isinstance(value, _PRIMITIVE_TYPES):
+        return value
+    if isinstance(value, (list, tuple)) and _is_homogeneous(value):
+        return list(value)
+    try:
+        encoded = json.dumps(value, allow_nan=False, default=_encode_string_like)
+    except (TypeError, ValueError):
+        return None
+    if encoded.startswith('"'):
+        return json.loads(encoded) or None
+    return encoded
+
+
+def _encode_string_like(value: Any) -> str:
+    if isinstance(value, (datetime.datetime, datetime.date, datetime.time)):
+        return value.isoformat()
+    if isinstance(value, (uuid.UUID, decimal.Decimal)):
+        return str(value)
+    raise TypeError(f"{type(value).__name__} is not JSON serializable")
+
+
+def _is_out_of_int64_range(value: Any) -> bool:
+    return (
+        isinstance(value, int)
+        and not isinstance(value, bool)
+        and not _MIN_INT64 <= value <= _MAX_INT64
+    )
+
+
+def _is_homogeneous(values: Sequence[Any]) -> bool:
+    return (
+        all(isinstance(v, _PRIMITIVE_TYPES) for v in values)
+        and not any(_is_out_of_int64_range(v) for v in values)
+        and all(math.isfinite(v) for v in values if isinstance(v, float))
+        and len({type(v) for v in values}) <= 1
+    )
diff --git a/posthog/ai/otel/exporter.py b/posthog/ai/otel/exporter.py
index 02c1c22e3..ec6e387ff 100644
--- a/posthog/ai/otel/exporter.py
+++ b/posthog/ai/otel/exporter.py
@@ -20,6 +20,8 @@ class PostHogTraceExporter(SpanExporter):
 
     Wraps an OTLPSpanExporter configured for PostHog's OTLP endpoint. Spans
     that are not AI-related are silently dropped, returning SUCCESS immediately.
+    Exporters only see finished spans, so they can't add per-request PostHog
+    context; use ``PostHogSpanProcessor`` for that.
 
     Usage::
 
diff --git a/posthog/ai/otel/processor.py b/posthog/ai/otel/processor.py
index 4f520591b..31073c54b 100644
--- a/posthog/ai/otel/processor.py
+++ b/posthog/ai/otel/processor.py
@@ -5,7 +5,11 @@
 for setups using TracerProvider.add_span_processor().
 """
 
-from typing import Optional
+import logging
+import os
+import threading
+import weakref
+from typing import Dict, Optional, Tuple
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
@@ -13,9 +17,43 @@
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
 from ..gateway import warn_if_posthog_ai_gateway_otel_attributes
+from ._request_context import (
+    RequestContext,
+    capture_request_context,
+    with_request_context,
+)
 from .spans import DEFAULT_HOST, is_ai_span
 
 
+log = logging.getLogger("posthog")
+
+
+def _span_key(span: ReadableSpan) -> Tuple[int, int]:
+    # The SDK passes on_end a ReadableSpan snapshot, not the Span object on_start saw.
+    context = span.get_span_context()
+    return (context.trace_id, context.span_id)
+
+
+_processors: "weakref.WeakSet[PostHogSpanProcessor]" = weakref.WeakSet()
+
+
+def _discard_abandoned(
+    processor_ref: "weakref.ref[PostHogSpanProcessor]", key: Tuple[int, int]
+) -> None:
+    processor = processor_ref()
+    if processor is not None:
+        processor._discard_captured(key)
+
+
+def _reset_processors_after_fork() -> None:
+    for processor in list(_processors):
+        processor._reset_after_fork()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_reset_processors_after_fork)
+
+
 class PostHogSpanProcessor(SpanProcessor):
     """Span processor that filters AI spans and exports them to PostHog.
 
@@ -32,6 +70,19 @@ class PostHogSpanProcessor(SpanProcessor):
         provider.add_span_processor(
             PostHogSpanProcessor(api_key="phc_...")
         )
+
+        # Per request: AI spans started inside a context export with its user, session and tags.
+        with posthog.new_context():
+            posthog.identify_context(user_id)
+            posthog.tag("plan", "pro")
+            handle_request()
+
+    Attributes already on a span win over explicit tags, which win over the
+    context's distinct ID and session ID (exported as ``$session_id``). Threads that don't copy contextvars
+    carry no user.
+
+    The context is captured when a span starts, but tag values are read when the
+    span ends. Mutating a tagged object while a span is open shows up in the export.
     """
 
     def __init__(
@@ -52,15 +103,50 @@ def __init__(
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
         self._processor = BatchSpanProcessor(exporter)
+        self._captured: Dict[
+            Tuple[int, int], Tuple[RequestContext, weakref.finalize]
+        ] = {}
+        # Reentrant: cyclic GC can run a span finalizer on a thread that already holds the lock.
+        self._captured_lock = threading.RLock()
+        _processors.add(self)
+
+    def _reset_after_fork(self) -> None:
+        # A lock held by another thread at fork time would never release in the child.
+        self._captured_lock = threading.RLock()
+        self._captured = {}
+
+    def _discard_captured(self, key: Tuple[int, int]) -> None:
+        with self._captured_lock:
+            self._captured.pop(key, None)
+
+    def _take_captured(self, key: Tuple[int, int]) -> Optional[RequestContext]:
+        with self._captured_lock:
+            entry = self._captured.pop(key, None)
+        if entry is None:
+            return None
+        captured, finalizer = entry
+        finalizer.detach()
+        return captured
 
     def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
         """
-        Handle span start notifications.
+        Remember the active PostHog context for the span.
 
-        This processor does not need to do work at span start; filtering happens
-        in ``on_end``.
+        The span itself is left untouched, so other processors on the provider
+        never see the context. The values are added to the copy exported to
+        PostHog in ``on_end``.
         """
-        pass
+        try:
+            captured = capture_request_context()
+            if captured:
+                key = _span_key(span)
+                finalizer = weakref.finalize(
+                    span, _discard_abandoned, weakref.ref(self), key
+                )
+                with self._captured_lock:
+                    self._captured[key] = (captured, finalizer)
+        except Exception:
+            log.debug("Failed to capture PostHog context for span", exc_info=True)
 
     def on_end(self, span: ReadableSpan) -> None:
         """
@@ -69,14 +155,24 @@ def on_end(self, span: ReadableSpan) -> None:
         Args:
             span: The ended OpenTelemetry span.
         """
+        captured = self._take_captured(_span_key(span))
         if not is_ai_span(span):
             return
         warn_if_posthog_ai_gateway_otel_attributes(span.attributes)
+        if captured:
+            try:
+                span = with_request_context(span, captured)
+            except Exception:
+                log.debug("Failed to add PostHog context to span", exc_info=True)
         self._processor.on_end(span)
 
     def shutdown(self) -> None:
         """Shut down the underlying batch span processor."""
         self._processor.shutdown()
+        with self._captured_lock:
+            for _, finalizer in self._captured.values():
+                finalizer.detach()
+            self._captured.clear()
 
     def force_flush(self, timeout_millis: Optional[int] = None) -> bool:
         """
diff --git a/posthog/test/ai/otel/test_processor.py b/posthog/test/ai/otel/test_processor.py
index c2e2c2694..06deb61a2 100644
--- a/posthog/test/ai/otel/test_processor.py
+++ b/posthog/test/ai/otel/test_processor.py
@@ -1,7 +1,17 @@
+import gc
+import json
+import threading
 import unittest
+import uuid
+from datetime import datetime, timezone
+from decimal import Decimal
+from concurrent.futures import ThreadPoolExecutor
 from unittest.mock import MagicMock, patch
 
-from posthog.ai.otel.processor import PostHogSpanProcessor
+from opentelemetry.sdk.trace import TracerProvider
+
+from posthog import contexts
+from posthog.ai.otel.processor import PostHogSpanProcessor, _reset_processors_after_fork
 from posthog.test.ai.otel.conftest import make_span
 
 
@@ -108,3 +118,294 @@ def test_force_flush_without_timeout(self, mock_batch_cls, mock_otlp_cls):
                 inner.force_flush.return_value = result
                 self.assertIs(processor.force_flush(), result)
                 inner.force_flush.assert_called_once_with()
+
+
+def new_request_context():
+    return contexts.new_context(fresh=True, capture_exceptions=False)
+
+
+class TestPostHogSpanProcessorRequestContext(unittest.TestCase):
+    def setUp(self):
+        exporter_patch = patch("posthog.ai.otel.processor.OTLPSpanExporter")
+        batch_patch = patch("posthog.ai.otel.processor.BatchSpanProcessor")
+        exporter_patch.start()
+        self.inner = batch_patch.start().return_value
+        self.addCleanup(exporter_patch.stop)
+        self.addCleanup(batch_patch.stop)
+        provider = TracerProvider()
+        self.processor = PostHogSpanProcessor(api_key="phc_test")
+        provider.add_span_processor(self.processor)
+        self.other_processor = MagicMock()
+        provider.add_span_processor(self.other_processor)
+        self.tracer = provider.get_tracer("test")
+
+    def _emit_span(self, name="gen_ai.chat", attributes=None):
+        with self.tracer.start_as_current_span(name, attributes=attributes):
+            pass
+
+    def _exported_attributes(self):
+        return [
+            dict(call.args[0].attributes) for call in self.inner.on_end.call_args_list
+        ]
+
+    def test_exports_distinct_id_session_and_tags(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            contexts.set_context_session("s_alice")
+            contexts.tag("plan", "pro")
+            self._emit_span()
+
+        self.assertEqual(
+            self._exported_attributes(),
+            [
+                {
+                    "posthog.distinct_id": "alice",
+                    "$session_id": "s_alice",
+                    "plan": "pro",
+                }
+            ],
+        )
+
+    def test_other_processors_do_not_see_the_context(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            contexts.tag("plan", "pro")
+            self._emit_span(attributes={"gen_ai.system": "openai"})
+
+        started = self.other_processor.on_start.call_args.args[0]
+        ended = self.other_processor.on_end.call_args.args[0]
+        self.assertEqual(dict(started.attributes), {"gen_ai.system": "openai"})
+        self.assertEqual(dict(ended.attributes), {"gen_ai.system": "openai"})
+
+    def test_drops_non_ai_spans_started_in_a_context(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            self._emit_span(name="http.request")
+
+        self.inner.on_end.assert_not_called()
+        self.assertEqual(self.processor._captured, {})
+
+    def test_shutdown_clears_captured_contexts(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            with self.tracer.start_as_current_span("gen_ai.chat"):
+                self.assertEqual(len(self.processor._captured), 1)
+                self.processor.shutdown()
+                self.assertEqual(self.processor._captured, {})
+
+    def test_keeps_attributes_already_on_the_span(self):
+        with new_request_context():
+            contexts.set_context_session("s_alice")
+            self._emit_span(attributes={"$session_id": "conv_42"})
+
+        self.assertEqual(self._exported_attributes()[0]["$session_id"], "conv_42")
+
+    def test_skips_context_distinct_id_when_span_has_an_identity(self):
+        identity_keys = (
+            "posthog.distinct_id",
+            "user.id",
+            "ai.telemetry.metadata.posthog_distinct_id",
+            "ai.settings.context.posthog_distinct_id",
+        )
+        for key in identity_keys:
+            with self.subTest(key=key):
+                self.inner.on_end.reset_mock()
+                with new_request_context():
+                    contexts.identify_context("alice")
+                    self._emit_span(attributes={key: "bob"})
+
+                attributes = self._exported_attributes()[0]
+                self.assertEqual(attributes[key], "bob")
+                if key != "posthog.distinct_id":
+                    self.assertNotIn("posthog.distinct_id", attributes)
+
+    def test_skips_distinct_id_tag_when_span_has_an_identity(self):
+        with new_request_context():
+            contexts.tag("posthog.distinct_id", "alice")
+            self._emit_span(attributes={"user.id": "bob"})
+
+        attributes = self._exported_attributes()[0]
+        self.assertEqual(attributes, {"user.id": "bob"})
+
+    def test_encodes_structured_tags_as_json(self):
+        with new_request_context():
+            contexts.tag("account", {"tier": "pro", "seats": 3})
+            contexts.tag("arms", ["short-prompt", "new-router"])
+            contexts.tag("mixed", ["a", 1])
+            contexts.tag("nested_not_finite", {"x": float("inf")})
+            self._emit_span()
+
+        attributes = self._exported_attributes()[0]
+        self.assertEqual(json.loads(attributes["account"]), {"tier": "pro", "seats": 3})
+        self.assertEqual(list(attributes["arms"]), ["short-prompt", "new-router"])
+        self.assertEqual(json.loads(attributes["mixed"]), ["a", 1])
+        self.assertNotIn("nested_not_finite", attributes)
+
+    def test_skips_non_finite_numbers(self):
+        with new_request_context():
+            contexts.tag("nan", float("nan"))
+            contexts.tag("inf", float("-inf"))
+            contexts.tag("list_with_inf", [1.0, float("inf")])
+            contexts.tag("plan", "pro")
+            self._emit_span()
+
+        self.assertEqual(self._exported_attributes(), [{"plan": "pro"}])
+
+    def test_string_like_values_arrive_as_plain_strings(self):
+        moment = datetime(2026, 10, 14, 8, 30, tzinfo=timezone.utc)
+        identifier = uuid.UUID("12345678-1234-5678-1234-567812345678")
+        with new_request_context():
+            contexts.tag("when", moment)
+            contexts.tag("id", identifier)
+            contexts.tag("price", Decimal("1.50"))
+            self._emit_span()
+
+        self.assertEqual(
+            self._exported_attributes(),
+            [{"when": moment.isoformat(), "id": str(identifier), "price": "1.50"}],
+        )
+
+    def test_skips_values_json_cannot_represent(self):
+        with new_request_context():
+            contexts.tag("tags", {"a", "b"})
+            contexts.tag("raw", b"bytes")
+            contexts.tag("plan", "pro")
+            self._emit_span()
+
+        self.assertEqual(self._exported_attributes(), [{"plan": "pro"}])
+
+    def test_tags_win_over_context_ids_and_survive_an_empty_context(self):
+        with new_request_context():
+            contexts.tag("$session_id", "conv_42")
+            self._emit_span()
+        with new_request_context():
+            contexts.set_context_session("s_alice")
+            contexts.tag("$session_id", "conv_42")
+            self._emit_span()
+
+        self.assertEqual(
+            [a["$session_id"] for a in self._exported_attributes()],
+            ["conv_42", "conv_42"],
+        )
+
+    def test_explicit_ai_session_id_tag_passes_through(self):
+        with new_request_context():
+            contexts.set_context_session("s_alice")
+            contexts.tag("$ai_session_id", "conv_42")
+            self._emit_span()
+
+        attributes = self._exported_attributes()[0]
+        self.assertEqual(attributes["$ai_session_id"], "conv_42")
+        self.assertEqual(attributes["$session_id"], "s_alice")
+
+    def test_context_session_does_not_set_ai_session_id(self):
+        with new_request_context():
+            contexts.set_context_session("s_alice")
+            self._emit_span()
+
+        self.assertNotIn("$ai_session_id", self._exported_attributes()[0])
+
+    def test_integers_outside_signed_64_bit_range_are_sent_as_strings(self):
+        with new_request_context():
+            contexts.tag("big", 2**63)
+            contexts.tag("small", -(2**63) - 1)
+            contexts.tag("edge", 2**63 - 1)
+            contexts.tag("bigs", [2**64, 1])
+            self._emit_span()
+
+        attributes = self._exported_attributes()[0]
+        self.assertEqual(attributes["big"], str(2**63))
+        self.assertEqual(attributes["small"], str(-(2**63) - 1))
+        self.assertEqual(attributes["edge"], 2**63 - 1)
+        self.assertEqual(json.loads(attributes["bigs"]), [2**64, 1])
+
+    def test_abandoned_span_entry_is_removed_when_garbage_collected(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            span = self.tracer.start_span("gen_ai.chat")
+        self.assertEqual(len(self.processor._captured), 1)
+
+        self.other_processor.reset_mock()
+        del span
+        gc.collect()
+
+        self.assertEqual(self.processor._captured, {})
+
+    def test_collecting_an_abandoned_span_does_not_deadlock_on_the_held_lock(self):
+        def collect_while_holding_lock():
+            with new_request_context():
+                contexts.identify_context("alice")
+                holder = []
+                span = self.tracer.start_span("gen_ai.chat")
+                holder.append(span)
+                holder.append(holder)
+            del span, holder
+            self.other_processor.reset_mock()
+            with self.processor._captured_lock:
+                gc.collect()
+
+        worker = threading.Thread(target=collect_while_holding_lock, daemon=True)
+        worker.start()
+        worker.join(timeout=5)
+
+        self.assertFalse(worker.is_alive(), "gc deadlocked on the captured lock")
+        self.assertEqual(self.processor._captured, {})
+
+    def test_finalizer_is_detached_once_the_span_ends(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            span = self.tracer.start_span("gen_ai.chat")
+        _, finalizer = next(iter(self.processor._captured.values()))
+        self.assertTrue(finalizer.alive)
+
+        span.end()
+
+        self.assertFalse(finalizer.alive)
+        self.assertEqual(self.processor._captured, {})
+
+    def test_after_fork_resets_lock_and_store(self):
+        with new_request_context():
+            contexts.identify_context("alice")
+            span = self.tracer.start_span("gen_ai.chat")
+        old_lock = self.processor._captured_lock
+
+        _reset_processors_after_fork()
+
+        self.assertIsNot(self.processor._captured_lock, old_lock)
+        self.assertEqual(self.processor._captured, {})
+        span.end()
+
+    def test_unstampable_tag_does_not_drop_the_other_tags(self):
+        class Unstampable(list):
+            def __iter__(self):
+                raise RuntimeError("cannot iterate")
+
+        with new_request_context():
+            contexts.tag("bad", Unstampable([1]))
+            contexts.tag("plan", "pro")
+            self._emit_span()
+
+        self.assertEqual(self._exported_attributes(), [{"plan": "pro"}])
+
+    def test_adds_nothing_without_a_context(self):
+        self._emit_span()
+
+        self.assertEqual(self._exported_attributes(), [{}])
+
+    def test_overlapping_requests_export_their_own_values(self):
+        both_started = threading.Barrier(2)
+
+        def request(user):
+            with new_request_context():
+                contexts.identify_context(user)
+                span = self.tracer.start_span("gen_ai.chat")
+            both_started.wait(timeout=5)
+            span.end()
+
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            list(pool.map(request, ["alice", "bob"]))
+
+        self.assertEqual(
+            sorted(a["posthog.distinct_id"] for a in self._exported_attributes()),
+            ["alice", "bob"],
+        )
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index f8ce5837d..b66a265f1 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -568,6 +568,7 @@ attribute posthog.ai.openai.openai_providers.AzureOpenAI.embeddings: WrappedEmbe
 attribute posthog.ai.openai.openai_providers.AzureOpenAI.responses: WrappedResponses
 attribute posthog.ai.openai.wrapper_utils.log = logging.getLogger('posthog')
 attribute posthog.ai.openai_agents.processor.log = logging.getLogger('posthog')
+attribute posthog.ai.otel.processor.log = logging.getLogger('posthog')
 attribute posthog.ai.otel.spans.AI_SPAN_PREFIXES = ('gen_ai.', 'llm.', 'ai.', 'traceloop.')
 attribute posthog.ai.otel.spans.DEFAULT_HOST = 'https://us.i.posthog.com'
 attribute posthog.ai.prompts.APP_ENDPOINT = 'https://us.posthog.com'

From a615eed8fb157f4dfa5e4d141a998c137c4b9ba3 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:54:22 +0000
Subject: [PATCH 024/245] chore: Release v7.70.0 [skip ci]

---
 .sampo/changesets/span-processor-request-context.md | 5 -----
 openfeature-provider/CHANGELOG.md                   | 6 ++++++
 openfeature-provider/pyproject.toml                 | 2 +-
 posthog/CHANGELOG.md                                | 6 ++++++
 posthog/version.py                                  | 2 +-
 pyproject.toml                                      | 2 +-
 uv.lock                                             | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/span-processor-request-context.md

diff --git a/.sampo/changesets/span-processor-request-context.md b/.sampo/changesets/span-processor-request-context.md
deleted file mode 100644
index 2d3b5f637..000000000
--- a/.sampo/changesets/span-processor-request-context.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-`PostHogSpanProcessor` now adds the active PostHog context to the AI spans it exports: the distinct ID from `identify_context`, the session ID from `set_context_session` (sent as `$session_id`), and context tags as properties. Spans started inside `posthog.new_context()` reach PostHog under the right person, so one process can trace many users. Tags set by the request middleware (for example `email`, `$ip`, `$user_agent` and `$current_url`) now appear on AI events too. Attributes already on a span are kept, and other processors on the provider never see the context. Apps already using PostHog contexts (for example the Django, Flask or ASGI request middleware) will see their AI events attributed to the context's person after upgrading.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index a187f190f..6e16d0a07 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.104 — 2026-10-14
+
+### Patch changes
+
+- Updated dependencies: posthog@7.70.0
+
 ## 0.1.103 — 2026-10-13
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3137266d0..d0daa292e 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.103"
+version = "0.1.104"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 424723c31..b6e350fdf 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.70.0 — 2026-10-14
+
+### Minor changes
+
+- [6916499](https://github.com/posthog/posthog-python/commit/69164994c920bbaf445c3a2c20b9f558f6a5a473) `PostHogSpanProcessor` now adds the active PostHog context to the AI spans it exports: the distinct ID from `identify_context`, the session ID from `set_context_session` (sent as `$session_id`), and context tags as properties. Spans started inside `posthog.new_context()` reach PostHog under the right person, so one process can trace many users. Tags set by the request middleware (for example `email`, `$ip`, `$user_agent` and `$current_url`) now appear on AI events too. Attributes already on a span are kept, and other processors on the provider never see the context. Apps already using PostHog contexts (for example the Django, Flask or ASGI request middleware) will see their AI events attributed to the context's person after upgrading. — Thanks @carlos-marchal-ph!
+
 ## 7.69.0 — 2026-10-13
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index fdd21fd65..76c542202 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.69.0"
+VERSION = "7.70.0"
diff --git a/pyproject.toml b/pyproject.toml
index f33639501..b67276094 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.69.0"
+version = "7.70.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index bd828339a..2535acd50 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.103"
+version = "0.1.104"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.69.0"
+version = "7.70.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From a49648e0a0f9842914df91c3d2790ad9e4edca71 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:54:27 +0000
Subject: [PATCH 025/245] Update generated references

---
 .../posthog-python-references-7.70.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.70.0.json

diff --git a/references/posthog-python-references-7.70.0.json b/references/posthog-python-references-7.70.0.json
new file mode 100644
index 000000000..6e46c32c7
--- /dev/null
+++ b/references/posthog-python-references-7.70.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.70.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index d407afdb1..6e46c32c7 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.69.0",
+    "version": "7.70.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 10d094e384efce1422ae1853951b7d2eaa0885ef Mon Sep 17 00:00:00 2001
From: Juraj Majerik <juro.majerik@gmail.com>
Date: Thu, 15 Oct 2026 17:11:41 +0200
Subject: [PATCH 026/245] fix(prompts): share one request between concurrent
 fetches of the same prompt (#1059)

---
 .sampo/changesets/prompts-single-flight.md |   5 +
 posthog/ai/prompts.py                      | 147 ++++++++++++++++-----
 posthog/test/ai/test_prompts.py            | 120 +++++++++++++++++
 3 files changed, 240 insertions(+), 32 deletions(-)
 create mode 100644 .sampo/changesets/prompts-single-flight.md

diff --git a/.sampo/changesets/prompts-single-flight.md b/.sampo/changesets/prompts-single-flight.md
new file mode 100644
index 000000000..6051ac9b1
--- /dev/null
+++ b/.sampo/changesets/prompts-single-flight.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+`Prompts.get()` now makes one request when several threads ask for the same prompt at once, instead of one request per thread. The other threads wait for that result. With `capture_errors=True`, a shared failure is reported once instead of once per thread.
diff --git a/posthog/ai/prompts.py b/posthog/ai/prompts.py
index 2cbae9db4..3a785f0ce 100644
--- a/posthog/ai/prompts.py
+++ b/posthog/ai/prompts.py
@@ -7,10 +7,13 @@
 import copy
 import logging
 import math
+import os
 import re
+import threading
 import time
 import urllib.parse
 import warnings
+import weakref
 from dataclasses import dataclass
 from typing import Any, Dict, List, Literal, Optional, Union, overload
 
@@ -37,6 +40,33 @@
 PromptSource = Literal["api", "cache", "stale_cache", "code_fallback"]
 
 
+class _InFlightFetch:
+    """One network request that several callers wait on."""
+
+    def __init__(self) -> None:
+        self.done = threading.Event()
+        self.result: Optional[CachedPrompt] = None
+        self.error: Optional[BaseException] = None
+
+
+# Every live Prompts instance, so one fork hook can reset them all. Registered
+# once here, because os.register_at_fork keeps each callback for the process
+# lifetime and an app that builds many instances would accumulate them.
+_instances: "weakref.WeakSet[Prompts]" = weakref.WeakSet()
+
+
+def _reset_in_flight_after_fork() -> None:
+    # The child has no copy of the thread that was fetching, so an inherited
+    # in-flight entry would hold every later caller for that key.
+    for prompts in list(_instances):
+        prompts._in_flight = {}
+        prompts._in_flight_lock = threading.Lock()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_reset_in_flight_after_fork)
+
+
 @dataclass(frozen=True)
 class PromptResult:
     """Result of a prompt fetch with metadata about its source.
@@ -270,6 +300,12 @@ def __init__(
             else DEFAULT_CACHE_TTL_SECONDS
         )
         self._cache: Dict[PromptCacheKey, CachedPrompt] = {}
+        # One request per cache key at a time. Threads that arrive while it is in
+        # flight wait for that result, so a worker with many concurrent callers does
+        # not turn every cache miss or expiry into one request per caller.
+        self._in_flight: Dict[PromptCacheKey, _InFlightFetch] = {}
+        self._in_flight_lock = threading.Lock()
+        _instances.add(self)
         self._has_warned_deprecation = False
         self._client = posthog
         self._capture_errors = capture_errors
@@ -568,44 +604,18 @@ def _get_internal(
 
         # Try to fetch from API
         try:
-            data = self._fetch_prompt_from_api(name, version, label)
-
-            # An older PostHog server ignores the label param and returns the latest
-            # version with no label field — surface that instead of failing silently.
-            if label is not None and data.get("label") != label:
-                log.warning(
-                    "[PostHog Prompts] Requested label %r for prompt %r but the server "
-                    "resolved %r. It may not support prompt labels yet and returned the "
-                    "latest version instead.",
-                    label,
-                    name,
-                    data.get("label"),
-                )
-
-            config = _extract_config(data)
-
-            # Update cache
-            self._cache[cache_key] = CachedPrompt(
-                prompt=data["prompt"],
-                fetched_at=time.time(),
-                name=data["name"],
-                version=data["version"],
-                label=data.get("label"),
-                config=config,
-            )
+            fetched = self._fetch_prompt_once(name, version, label, ttl=ttl)
 
             return PromptResult(
                 source="api",
-                prompt=data["prompt"],
-                name=data["name"],
-                version=data["version"],
-                label=data.get("label"),
-                config=copy.deepcopy(config),
+                prompt=fetched.prompt,
+                name=fetched.name,
+                version=fetched.version,
+                label=fetched.label,
+                config=copy.deepcopy(fetched.config),
             )
 
         except Exception as error:
-            self._maybe_capture_error(error, name=name, version=version, label=label)
-
             prompt_reference = _prompt_reference(name, version, label)
             # Return stale cache (with warning)
             if cached is not None:
@@ -634,6 +644,79 @@ def _get_internal(
 
             raise
 
+    def _fetch_prompt_once(
+        self,
+        name: str,
+        version: Optional[int],
+        label: Optional[str],
+        *,
+        ttl: float,
+    ) -> CachedPrompt:
+        """Fetch a prompt, sharing the request with other threads that want the same key."""
+        cache_key = _cache_key(name, version, label)
+        with self._in_flight_lock:
+            # Another thread may have finished a fetch between the caller's cache
+            # check and this lock. Its entry is fresh, so serve it instead of
+            # starting another request. A zero TTL is never fresh and still fetches.
+            cached = self._cache.get(cache_key)
+            if cached is not None and (time.time() - cached.fetched_at) < ttl:
+                return cached
+
+            pending = self._in_flight.get(cache_key)
+            is_leader = pending is None
+            if pending is None:
+                pending = _InFlightFetch()
+                self._in_flight[cache_key] = pending
+
+        if not is_leader:
+            pending.done.wait()
+            if pending.error is not None:
+                raise pending.error
+            assert pending.result is not None
+            return pending.result
+
+        try:
+            data = self._fetch_prompt_from_api(name, version, label)
+
+            # An older PostHog server ignores the label param and returns the latest
+            # version with no label field — surface that instead of failing silently.
+            if label is not None and data.get("label") != label:
+                log.warning(
+                    "[PostHog Prompts] Requested label %r for prompt %r but the server "
+                    "resolved %r. It may not support prompt labels yet and returned the "
+                    "latest version instead.",
+                    label,
+                    name,
+                    data.get("label"),
+                )
+
+            fetched = CachedPrompt(
+                prompt=data["prompt"],
+                fetched_at=time.time(),
+                name=data["name"],
+                version=data["version"],
+                label=data.get("label"),
+                config=_extract_config(data),
+            )
+            # Cached before the in-flight entry is released, so a caller that
+            # arrives in between finds the entry instead of starting a request.
+            self._cache[cache_key] = fetched
+            pending.result = fetched
+            return fetched
+        except BaseException as error:
+            pending.error = error
+            raise
+        finally:
+            with self._in_flight_lock:
+                self._in_flight.pop(cache_key, None)
+            pending.done.set()
+            # Reported after the waiters are released, so an error-tracking callback
+            # that fetches the same prompt cannot wait on this very request.
+            if isinstance(pending.error, Exception):
+                self._maybe_capture_error(
+                    pending.error, name=name, version=version, label=label
+                )
+
     def compile(self, prompt: str, variables: PromptVariables) -> str:
         """
         Replace {{variableName}} placeholders with values.
diff --git a/posthog/test/ai/test_prompts.py b/posthog/test/ai/test_prompts.py
index 4e124f16d..7072bc90c 100644
--- a/posthog/test/ai/test_prompts.py
+++ b/posthog/test/ai/test_prompts.py
@@ -1,3 +1,4 @@
+import threading
 import unittest
 import warnings
 from unittest.mock import MagicMock, patch
@@ -382,6 +383,125 @@ def test_hold_a_cooldown_after_each_failed_refetch(
         self.assertEqual(result.source, "api")
         self.assertEqual(mock_get.call_count, 4)
 
+    def _run_concurrent_gets(self, prompts, calls):
+        results = [None] * len(calls)
+        start_together = threading.Barrier(len(calls))
+
+        def run(index, kwargs):
+            start_together.wait(5)
+            results[index] = prompts.get("test-prompt", with_metadata=True, **kwargs)
+
+        threads = [
+            threading.Thread(target=run, args=(index, kwargs))
+            for index, kwargs in enumerate(calls)
+        ]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join(timeout=5)
+        return results
+
+    @patch("posthog.ai.prompts._get_session")
+    def test_share_one_request_between_concurrent_callers(self, mock_get_session):
+        mock_get = mock_get_session.return_value.get
+        release = threading.Event()
+
+        def slow_get(url, **kwargs):
+            release.wait(5)
+            version = 2 if "version=2" in url else 1
+            return MockResponse(
+                json_data={**self.mock_prompt_response, "version": version}
+            )
+
+        mock_get.side_effect = slow_get
+        prompts = Prompts(self.create_mock_posthog())
+
+        calls = [{}] * 10 + [{"version": 2}]
+
+        # Release the network once every caller is waiting on it.
+        timer = threading.Timer(0.2, release.set)
+        timer.start()
+        results = self._run_concurrent_gets(prompts, calls)
+        timer.join()
+
+        self.assertEqual(mock_get.call_count, 2)
+        self.assertEqual({r.source for r in results}, {"api"})
+        self.assertEqual([r.version for r in results[:10]], [1] * 10)
+        self.assertEqual(results[10].version, 2)
+
+    @patch("posthog.ai.prompts._get_session")
+    def test_concurrent_callers_share_one_failure_and_capture_it_once(
+        self, mock_get_session
+    ):
+        mock_get = mock_get_session.return_value.get
+        release = threading.Event()
+
+        def failing_get(url, **kwargs):
+            release.wait(5)
+            raise Exception("Network error")
+
+        mock_get.side_effect = failing_get
+        posthog = self.create_mock_posthog()
+        prompts = Prompts(posthog, capture_errors=True)
+
+        timer = threading.Timer(0.2, release.set)
+        timer.start()
+        results = self._run_concurrent_gets(
+            prompts, [{"fallback": "fallback prompt"}] * 10
+        )
+        timer.join()
+
+        self.assertEqual(mock_get.call_count, 1)
+        self.assertEqual({r.source for r in results}, {"code_fallback"})
+        posthog.capture_exception.assert_called_once()
+
+    @patch("posthog.ai.prompts._get_session")
+    def test_fork_hook_clears_inherited_in_flight_entries(self, mock_get_session):
+        from posthog.ai.prompts import (
+            _InFlightFetch,
+            _cache_key,
+            _reset_in_flight_after_fork,
+        )
+
+        mock_get = mock_get_session.return_value.get
+        mock_get.return_value = MockResponse(json_data=self.mock_prompt_response)
+        prompts = Prompts(self.create_mock_posthog())
+        # What a forked child inherits: an entry whose fetching thread no longer exists.
+        prompts._in_flight[_cache_key("test-prompt", None, None)] = _InFlightFetch()
+
+        _reset_in_flight_after_fork()
+        result = prompts.get("test-prompt", with_metadata=True)
+
+        self.assertEqual(result.source, "api")
+        self.assertEqual(mock_get.call_count, 1)
+
+    @patch("posthog.ai.prompts._get_session")
+    def test_error_callback_that_fetches_the_same_prompt_does_not_deadlock(
+        self, mock_get_session
+    ):
+        mock_get = mock_get_session.return_value.get
+        mock_get.side_effect = Exception("Network error")
+        posthog = self.create_mock_posthog()
+        prompts = Prompts(posthog, capture_errors=True)
+        nested_results = []
+        entered = threading.Event()
+
+        def capture_exception(*args, **kwargs):
+            # The nested fetch fails too and reports again; only the first report fetches.
+            if entered.is_set():
+                return
+            entered.set()
+            nested_results.append(
+                prompts.get("test-prompt", with_metadata=True, fallback="nested")
+            )
+
+        posthog.capture_exception.side_effect = capture_exception
+
+        result = prompts.get("test-prompt", with_metadata=True, fallback="outer")
+
+        self.assertEqual(result.prompt, "outer")
+        self.assertEqual([r.prompt for r in nested_results], ["nested"])
+
     @patch("posthog.ai.prompts._get_session")
     @patch("posthog.ai.prompts.log")
     def test_use_fallback_when_no_cache_and_fetch_fails_with_warning(

From ec71a24065b34fb326f5022a9c0225398f82ec75 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 15 Oct 2026 16:07:14 +0000
Subject: [PATCH 027/245] chore: Release v7.70.1 [skip ci]

---
 .sampo/changesets/prompts-single-flight.md | 5 -----
 openfeature-provider/CHANGELOG.md          | 6 ++++++
 openfeature-provider/pyproject.toml        | 2 +-
 posthog/CHANGELOG.md                       | 6 ++++++
 posthog/version.py                         | 2 +-
 pyproject.toml                             | 2 +-
 uv.lock                                    | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/prompts-single-flight.md

diff --git a/.sampo/changesets/prompts-single-flight.md b/.sampo/changesets/prompts-single-flight.md
deleted file mode 100644
index 6051ac9b1..000000000
--- a/.sampo/changesets/prompts-single-flight.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-`Prompts.get()` now makes one request when several threads ask for the same prompt at once, instead of one request per thread. The other threads wait for that result. With `capture_errors=True`, a shared failure is reported once instead of once per thread.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 6e16d0a07..d1e981944 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.105 — 2026-10-15
+
+### Patch changes
+
+- Updated dependencies: posthog@7.70.1
+
 ## 0.1.104 — 2026-10-14
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index d0daa292e..b4504c8b5 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.104"
+version = "0.1.105"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index b6e350fdf..7dbe1ba87 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.70.1 — 2026-10-15
+
+### Patch changes
+
+- [10d094e](https://github.com/posthog/posthog-python/commit/10d094e384efce1422ae1853951b7d2eaa0885ef) `Prompts.get()` now makes one request when several threads ask for the same prompt at once, instead of one request per thread. The other threads wait for that result. With `capture_errors=True`, a shared failure is reported once instead of once per thread. — Thanks @jurajmajerik!
+
 ## 7.70.0 — 2026-10-14
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 76c542202..b4fa8dd98 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.70.0"
+VERSION = "7.70.1"
diff --git a/pyproject.toml b/pyproject.toml
index b67276094..871eaec62 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.70.0"
+version = "7.70.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 2535acd50..6a3f9a543 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.104"
+version = "0.1.105"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.0"
+version = "7.70.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From fc3c4347d3371dc84dc4ea0276d3355c353a2eb7 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 15 Oct 2026 16:07:20 +0000
Subject: [PATCH 028/245] Update generated references

---
 .../posthog-python-references-7.70.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.70.1.json

diff --git a/references/posthog-python-references-7.70.1.json b/references/posthog-python-references-7.70.1.json
new file mode 100644
index 000000000..affb9655a
--- /dev/null
+++ b/references/posthog-python-references-7.70.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.70.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 6e46c32c7..affb9655a 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.70.0",
+    "version": "7.70.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From fec41f24cb497d37a8cd0dd53490b74c98554dfa Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Thu, 15 Oct 2026 23:59:18 +0700
Subject: [PATCH 029/245] fix(ai): mark cancelled async LLM calls as errors
 (#1065)

* fix(ai): mark cancelled async LLM calls as errors

* test: fix Python 3.10 cancellation and FastMCP compatibility
---
 .../venerable-baroness-lemminkainen.md        |  5 ++
 posthog/ai/utils.py                           |  8 ++
 posthog/test/ai/gemini/test_gemini_async.py   | 27 ++++++
 posthog/test/ai/test_async_cancellation.py    | 87 +++++++++++++++++++
 posthog/test/mcp/test_fastmcp_v4.py           |  2 -
 5 files changed, 127 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/venerable-baroness-lemminkainen.md
 create mode 100644 posthog/test/ai/test_async_cancellation.py

diff --git a/.sampo/changesets/venerable-baroness-lemminkainen.md b/.sampo/changesets/venerable-baroness-lemminkainen.md
new file mode 100644
index 000000000..5dc5c3502
--- /dev/null
+++ b/.sampo/changesets/venerable-baroness-lemminkainen.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Mark cancelled async LLM calls as errors while preserving cancellation.
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index ffc2c864c..c943bcc28 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import time
 import uuid
@@ -648,6 +649,13 @@ async def call_llm_and_track_usage_async(
 
         try:
             response = await call_async_method(**kwargs)
+        except asyncio.CancelledError:
+            http_status = 0
+            error_params = {
+                "$ai_is_error": True,
+                "$ai_error": "cancelled",
+            }
+            raise
         except Exception as exc:
             error = exc
             http_status = getattr(
diff --git a/posthog/test/ai/gemini/test_gemini_async.py b/posthog/test/ai/gemini/test_gemini_async.py
index 8dc51ca34..b4e63c019 100644
--- a/posthog/test/ai/gemini/test_gemini_async.py
+++ b/posthog/test/ai/gemini/test_gemini_async.py
@@ -1,3 +1,4 @@
+import asyncio
 import os
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -150,6 +151,32 @@ async def test_async_client_basic_generation(
     assert props["$ai_latency"] > 0
 
 
+async def test_async_client_timeout_captures_error(
+    mock_client, mock_google_genai_client
+):
+    async def slow_call(**kwargs):
+        await asyncio.Event().wait()
+
+    mock_google_genai_client.aio.models.generate_content = AsyncMock(
+        side_effect=slow_call
+    )
+    client = AsyncClient(api_key="test-key", posthog_client=mock_client)
+
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(
+            client.models.generate_content(model="gemini-x", contents="Hello"),
+            timeout=0.01,
+        )
+
+    assert mock_client.capture.call_count == 1
+    event = mock_client.capture.call_args.kwargs
+    assert event["event"] == "$ai_generation"
+    props = event["properties"]
+    assert props["$ai_http_status"] == 0
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "cancelled"
+
+
 async def test_async_client_streaming_with_generate_content_stream(
     mock_client, mock_google_genai_client
 ):
diff --git a/posthog/test/ai/test_async_cancellation.py b/posthog/test/ai/test_async_cancellation.py
new file mode 100644
index 000000000..f247bbcdf
--- /dev/null
+++ b/posthog/test/ai/test_async_cancellation.py
@@ -0,0 +1,87 @@
+import asyncio
+
+import pytest
+
+from posthog import Posthog
+from posthog.ai.utils import call_llm_and_track_usage_async
+
+
+@pytest.fixture
+def captured_generations():
+    events = []
+
+    def before_send(event):
+        if event["event"] == "$ai_generation":
+            events.append(event)
+        return None
+
+    client = Posthog("phc_test", before_send=before_send, sync_mode=True)
+    try:
+        yield client, events
+    finally:
+        client.shutdown()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("provider", ["gemini", "openai", "anthropic"])
+async def test_cancelled_call_captures_error_and_preserves_cancellation(
+    captured_generations, provider
+):
+    client, events = captured_generations
+    started = asyncio.Event()
+
+    async def slow_call(**kwargs):
+        started.set()
+        await asyncio.Event().wait()
+
+    task = asyncio.create_task(
+        call_llm_and_track_usage_async(
+            "user-1",
+            client,
+            provider,
+            "trace-1",
+            None,
+            False,
+            None,
+            "",
+            slow_call,
+            model="test-model",
+        )
+    )
+    await started.wait()
+    task.cancel("request cancelled")
+
+    with pytest.raises(asyncio.CancelledError):
+        await task
+
+    assert task.cancelled()
+    assert len(events) == 1
+    props = events[0]["properties"]
+    assert props["$ai_http_status"] == 0
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "cancelled"
+    assert props["$ai_provider"] == provider
+    assert props["$ai_trace_id"] == "trace-1"
+    assert "$ai_input_tokens" not in props
+    assert "$ai_output_tokens" not in props
+
+
+@pytest.mark.asyncio
+async def test_provider_error_is_captured_and_reraised(captured_generations):
+    client, events = captured_generations
+    error = RuntimeError("provider error")
+
+    async def failing_call(**kwargs):
+        raise error
+
+    with pytest.raises(RuntimeError) as exc_info:
+        await call_llm_and_track_usage_async(
+            None, client, "gemini", None, None, False, None, "", failing_call
+        )
+
+    assert exc_info.value is error
+    assert len(events) == 1
+    props = events[0]["properties"]
+    assert props["$ai_http_status"] == 0
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "provider error"
diff --git a/posthog/test/mcp/test_fastmcp_v4.py b/posthog/test/mcp/test_fastmcp_v4.py
index ac29c3a9f..1d5afe45c 100644
--- a/posthog/test/mcp/test_fastmcp_v4.py
+++ b/posthog/test/mcp/test_fastmcp_v4.py
@@ -152,7 +152,6 @@ def echo(context: str, conversation_id: str, llm_model: str) -> str:
     tool = Tool.from_function(echo)
     if source == "middleware":
         child.add_middleware(ToolInjectionMiddleware(tools=[tool]))
-        assert await child.get_tool("echo") is None
     else:
         child.add_tool(tool)
     server = FastMCP("example-app") if source == "mounted" else child
@@ -225,7 +224,6 @@ def echo(text: str) -> str:
 
     server = FastMCP("example-middleware-tools")
     server.add_middleware(ToolInjectionMiddleware(tools=[Tool.from_function(echo)]))
-    assert await server.get_tool("echo") is None
     sink = FakeClient()
     instrument(
         server,

From e3818080b5aa2f7f885b3b99643a7f34f9f9f3d8 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 15 Oct 2026 17:02:16 +0000
Subject: [PATCH 030/245] chore: Release v7.70.2 [skip ci]

---
 .sampo/changesets/venerable-baroness-lemminkainen.md | 5 -----
 openfeature-provider/CHANGELOG.md                    | 6 ++++++
 openfeature-provider/pyproject.toml                  | 2 +-
 posthog/CHANGELOG.md                                 | 6 ++++++
 posthog/version.py                                   | 2 +-
 pyproject.toml                                       | 2 +-
 uv.lock                                              | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/venerable-baroness-lemminkainen.md

diff --git a/.sampo/changesets/venerable-baroness-lemminkainen.md b/.sampo/changesets/venerable-baroness-lemminkainen.md
deleted file mode 100644
index 5dc5c3502..000000000
--- a/.sampo/changesets/venerable-baroness-lemminkainen.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Mark cancelled async LLM calls as errors while preserving cancellation.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index d1e981944..9ec2bd183 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.106 — 2026-10-15
+
+### Patch changes
+
+- Updated dependencies: posthog@7.70.2
+
 ## 0.1.105 — 2026-10-15
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index b4504c8b5..3bb79a00d 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.105"
+version = "0.1.106"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 7dbe1ba87..1e1e76b84 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.70.2 — 2026-10-15
+
+### Patch changes
+
+- [fec41f2](https://github.com/posthog/posthog-python/commit/fec41f24cb497d37a8cd0dd53490b74c98554dfa) Mark cancelled async LLM calls as errors while preserving cancellation. — Thanks @marandaneto!
+
 ## 7.70.1 — 2026-10-15
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index b4fa8dd98..c4ce44e4d 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.70.1"
+VERSION = "7.70.2"
diff --git a/pyproject.toml b/pyproject.toml
index 871eaec62..fab4ae8b1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.70.1"
+version = "7.70.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 6a3f9a543..407b256eb 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.105"
+version = "0.1.106"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.1"
+version = "7.70.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From f33d55d0f1fd01698140cff73e21b9f65bd1f0d7 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 15 Oct 2026 17:02:22 +0000
Subject: [PATCH 031/245] Update generated references

---
 .../posthog-python-references-7.70.2.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.70.2.json

diff --git a/references/posthog-python-references-7.70.2.json b/references/posthog-python-references-7.70.2.json
new file mode 100644
index 000000000..598946836
--- /dev/null
+++ b/references/posthog-python-references-7.70.2.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.70.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Tell the client to flush all queued events.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import flush\nflush()"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index affb9655a..598946836 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.70.1",
+    "version": "7.70.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From f44cf19625a05bee8443c1d09b48708f514c693c Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Fri, 16 Oct 2026 00:06:16 +0700
Subject: [PATCH 032/245] test(mcp): remove outdated FastMCP middleware
 discovery assumptions (#1066)

* test(mcp): remove outdated middleware discovery assumptions

* chore: remove changeset for test-only fix

From f95e1f46ef4de0b6903750583f3d63843a6dd685 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 17:45:53 +0000
Subject: [PATCH 033/245] chore(deps): bump the ai-providers group with 8
 updates (#1054)

Bumps the ai-providers group with 8 updates:

| Package | From | To |
| --- | --- | --- |
| [langchain](https://github.com/langchain-ai/langchain) | `1.4.2` | `1.4.3` |
| [anthropic](https://github.com/anthropics/anthropic-sdk-python) | `1.8.0` | `1.11.0` |
| [langgraph](https://github.com/langchain-ai/langgraph) | `1.2.12` | `1.2.13` |
| [langchain-core](https://github.com/langchain-ai/langchain) | `1.6.5` | `1.6.6` |
| [langchain-openai](https://github.com/langchain-ai/langchain) | `1.6.6` | `1.6.7` |
| [langchain-anthropic](https://github.com/langchain-ai/langchain) | `1.7.4` | `1.7.5` |
| [google-genai](https://github.com/googleapis/python-genai) | `2.25.0` | `2.28.0` |
| [langchain-text-splitters](https://github.com/langchain-ai/langchain) | `1.1.2` | `1.1.3` |


Updates `langchain` from 1.4.2 to 1.4.3
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain==1.4.2...langchain==1.4.3)

Updates `anthropic` from 1.8.0 to 1.11.0
- [Release notes](https://github.com/anthropics/anthropic-sdk-python/releases)
- [Changelog](https://github.com/anthropics/anthropic-sdk-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/anthropics/anthropic-sdk-python/compare/v1.8.0...v1.11.0)

Updates `langgraph` from 1.2.12 to 1.2.13
- [Release notes](https://github.com/langchain-ai/langgraph/releases)
- [Commits](https://github.com/langchain-ai/langgraph/compare/1.2.12...1.2.13)

Updates `langchain-core` from 1.6.5 to 1.6.6
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-core==1.6.5...langchain-core==1.6.6)

Updates `langchain-openai` from 1.6.6 to 1.6.7
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-openai==1.6.6...langchain-openai==1.6.7)

Updates `langchain-anthropic` from 1.7.4 to 1.7.5
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-anthropic==1.7.4...langchain-anthropic==1.7.5)

Updates `google-genai` from 2.25.0 to 2.28.0
- [Release notes](https://github.com/googleapis/python-genai/releases)
- [Changelog](https://github.com/googleapis/python-genai/blob/main/CHANGELOG.md)
- [Commits](https://github.com/googleapis/python-genai/compare/v2.25.0...v2.28.0)

Updates `langchain-text-splitters` from 1.1.2 to 1.1.3
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-text-splitters==1.1.2...langchain-text-splitters==1.1.3)

---
updated-dependencies:
- dependency-name: langchain
  dependency-version: 1.4.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: anthropic
  dependency-version: 1.11.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
- dependency-name: langgraph
  dependency-version: 1.2.13
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-core
  dependency-version: 1.6.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-openai
  dependency-version: 1.6.7
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-anthropic
  dependency-version: 1.7.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: google-genai
  dependency-version: 2.28.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
- dependency-name: langchain-text-splitters
  dependency-version: 1.1.3
  dependency-type: indirect
  update-type: version-update:semver-patch
  dependency-group: ai-providers
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Dustin Byrne <dustin@posthog.com>
---
 uv.lock | 48 ++++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/uv.lock b/uv.lock
index 407b256eb..c08152be8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -226,7 +226,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "1.8.0"
+version = "1.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -237,9 +237,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/65/b8/f4de0e90bbd641e86a1d6b20e017442033a2c1d2f5381799f82057115bd7/anthropic-1.8.0.tar.gz", hash = "sha256:9c1783ed90f409617749a61c5ab98e20624a572626f2e0a15cea03ed8e1401e5", size = 1221762, upload-time = "2026-09-22T16:25:38.167Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ad/12/9a6ffa397b172adb040008d934a1dfd85d0e4cefc77489416db294ffc880/anthropic-1.11.0.tar.gz", hash = "sha256:3906fabac7ad7b5b46c6186040398fc7826885c77ce34e4dd7849de16fc8d0f8", size = 1390390, upload-time = "2026-09-30T22:58:21.098Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5b/18/5d25a703b66ba34e9277f875f692a3bea3b0ff4d47ee5d188521a01cdd2a/anthropic-1.8.0-py3-none-any.whl", hash = "sha256:79a4516a21e64fd7b15be1a49ebf544bd6376c96a971a77365358823a2717bc6", size = 1348276, upload-time = "2026-09-22T16:25:36.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/6f/20edcd2956cac68042b1bcdd13ab3311447519f86b26929ff268dc74c650/anthropic-1.11.0-py3-none-any.whl", hash = "sha256:52f97b2c485cca7ac66058374f5073a3febb7e6849b16989c145d602a3efee21", size = 1681654, upload-time = "2026-09-30T22:58:22.925Z" },
 ]
 
 [[package]]
@@ -1146,7 +1146,7 @@ requests = [
 
 [[package]]
 name = "google-genai"
-version = "2.25.0"
+version = "2.28.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1160,9 +1160,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/62/0a/a3b7856ca840031d4393dbdd97b67fe811b20061315ed68b67b5c85ca80d/google_genai-2.25.0.tar.gz", hash = "sha256:ab603baa5eee0205926ad0f8d7f93e0400df6d67650e99c33e01ab228ea16ad6", size = 699564, upload-time = "2026-09-22T17:23:01.238Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/59/16/4af15d65cb72ebc21a99c5e64f09072e97334c05a48d4cede19c347e6ad2/google_genai-2.28.0.tar.gz", hash = "sha256:970cb2eaf1951949851c3e0a5b70265cfea8a408fb7361c7c980a84d90672bf2", size = 707359, upload-time = "2026-10-02T17:58:14.454Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/a8/178dbb9d1d6cac721b01592e291146a024bae5ee3224e36569348921dd6c/google_genai-2.25.0-py3-none-any.whl", hash = "sha256:2e8f3a5f76ed00d5ffc3153f6089bc7d3511054eed53ad9cfc6095a7dc59b028", size = 1159631, upload-time = "2026-09-22T17:22:59.291Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4b/47278c34757293ba8d9156090d38e1c45fac9a47c50176acff7f77ae9a66/google_genai-2.28.0-py3-none-any.whl", hash = "sha256:cdee15e2fbfea08ea61bce6e5bfbb3301db4bd13a52dccfa8c8d1167e37ca1cc", size = 1168554, upload-time = "2026-10-02T17:58:12.585Z" },
 ]
 
 [[package]]
@@ -1640,30 +1640,30 @@ wheels = [
 
 [[package]]
 name = "langchain"
-version = "1.4.2"
+version = "1.4.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "langgraph" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1c/ff/670036674e669b81c0ddba77e1f012c099eda7b7d1251b973e5367d2824e/langchain-1.4.2.tar.gz", hash = "sha256:5b476418cacbfb8f0da6e63b3b263eefdcec13b48abd6117565a25728ec10b77", size = 735715, upload-time = "2026-09-18T17:31:11.42Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/aa/0fcaf5d7dbebcf7d0eb74293dca5aee6f0558242731f4dee4a800cc2431d/langchain-1.4.3.tar.gz", hash = "sha256:aed5c1a7cd581f70ddc076b75fdbcbae8031b8373983f86efd287aa70798abc2", size = 738607, upload-time = "2026-09-28T20:17:24.38Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/86/cc13651cfda820d96ca8c612538166334935e8cf4331a31f5dd369d27760/langchain-1.4.2-py3-none-any.whl", hash = "sha256:30a27c34cfa0004bf659dcdef488b99a9b90acb08bcc514a5a74264755da536c", size = 163740, upload-time = "2026-09-18T17:31:10.056Z" },
+    { url = "https://files.pythonhosted.org/packages/30/03/8cc027f9d297473de94f134546dae2bfca255161ebbda988522fc509e1d5/langchain-1.4.3-py3-none-any.whl", hash = "sha256:0334066939dd1c7551889727ed2d09a72dea7a6aed2193ffb61817fb658d8921", size = 164708, upload-time = "2026-09-28T20:17:22.978Z" },
 ]
 
 [[package]]
 name = "langchain-anthropic"
-version = "1.7.4"
+version = "1.7.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anthropic" },
     { name = "langchain-core" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/83/f8/b1a7e19a4f129f567f04534e263e14e350673fb35ba5e45b2a189c07d85b/langchain_anthropic-1.7.4.tar.gz", hash = "sha256:7d540300665a1c906986e505cdec41204e759f14dbd989f53f0c180d82624b94", size = 760340, upload-time = "2026-09-23T17:55:49.262Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/e6/45ead93ef6d9f244b502a6a32bf9a185b3da1cc7fa8003896a102dadac09/langchain_anthropic-1.7.5.tar.gz", hash = "sha256:6016f38e5c4bf12c16ecfa76abf133a978f459f4d2887b8e28435ae1ff00beb3", size = 764625, upload-time = "2026-09-29T15:22:07.106Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/2c/d0389b1d8d4a93eadaa9cda07ef7614c0bbfec71f69997d42c32dabbbefa/langchain_anthropic-1.7.4-py3-none-any.whl", hash = "sha256:eec1178389358eaa4cff4f3dd353f063746b8c61090cffe9236d9035df71e66c", size = 63854, upload-time = "2026-09-23T17:55:48.137Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/a8/c507f2c1859b584843983e98bc71e0066c16a77e6c181921c928e0fdbcf7/langchain_anthropic-1.7.5-py3-none-any.whl", hash = "sha256:b21ef0e0c2d6175235a5b7eef4f5f89057df92d42dbfab66920a05605ef7173a", size = 65239, upload-time = "2026-09-29T15:22:05.832Z" },
 ]
 
 [[package]]
@@ -1710,7 +1710,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.6.5"
+version = "1.6.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1724,14 +1724,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ed/ed/ceecd3bfcfc77a94cf30a9f1506e907fdea447458825e01914a72d2d1a6f/langchain_core-1.6.5.tar.gz", hash = "sha256:bdb059fef65473fd444558dbb18f50901657402c43ceed9dc0fdc7b76a393c6b", size = 1007041, upload-time = "2026-09-24T18:11:06.487Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/87/9e5d393bbcec068c51becc255a15aacfd8a14ac5826179751c1c320e5258/langchain_core-1.6.6.tar.gz", hash = "sha256:67616d984c085009be2c381c2efd330d32429a58aebab295b4f51b6573964511", size = 1007227, upload-time = "2026-09-29T14:52:54.598Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/59/68/447ac7e734990b7ed9dcfc3b6dee9a4cd4d4169e296429fa71a9a47c1c7b/langchain_core-1.6.5-py3-none-any.whl", hash = "sha256:54c7b0e9314b9084fb04405bb33dc5d32986d512d92b7b8863899cd5f6267556", size = 572136, upload-time = "2026-09-24T18:11:04.837Z" },
+    { url = "https://files.pythonhosted.org/packages/90/10/8c00b4dc094886314c907ec7ead258dfee28948cf44175976cc4fba9aba8/langchain_core-1.6.6-py3-none-any.whl", hash = "sha256:d9a71e312ab7443701238750e04a57aefc037c4f1ec82837c8a1609d9a14a9b1", size = 572080, upload-time = "2026-09-29T14:52:53.213Z" },
 ]
 
 [[package]]
 name = "langchain-openai"
-version = "1.6.6"
+version = "1.6.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -1739,9 +1739,9 @@ dependencies = [
     { name = "openai" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/30/14/6d9c4d07b43c1eaf8a112be3524b951247c44bb195d6224cab8ffb68b3e8/langchain_openai-1.6.6.tar.gz", hash = "sha256:7b3848f42825aca40165463aa37757051165eb292ba7f24658a2f58f9bb221f9", size = 3306663, upload-time = "2026-09-24T11:31:13.55Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/2f/367068190b5a7d181996ad7899052394f0276468c92be48e0b7dab63716a/langchain_openai-1.6.7.tar.gz", hash = "sha256:b276a01b43c5287382f62070a4e1ca5bad5581fadab8c086e46b79daa4bf975d", size = 3380633, upload-time = "2026-09-30T15:12:03.1Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/c6/0f6b0c9faa7d00eef702c133fd3534cb52cbdf56df9f3524666012ec90e0/langchain_openai-1.6.6-py3-none-any.whl", hash = "sha256:60dcaa443ddfdf1559feaf1d25916f394c7dda809aebe22a769fc39f02705be7", size = 127401, upload-time = "2026-09-24T11:31:11.691Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d9/b3db61c6c15766c999194a9cba0b9c5035567b7e0dd1c1a94a6d76448cd6/langchain_openai-1.6.7-py3-none-any.whl", hash = "sha256:e1b9b318fafc47b2dbc3485778aa23f809195065ee313611c188af29744b8e8e", size = 127883, upload-time = "2026-09-30T15:12:01.876Z" },
 ]
 
 [[package]]
@@ -1758,19 +1758,19 @@ wheels = [
 
 [[package]]
 name = "langchain-text-splitters"
-version = "1.1.2"
+version = "1.1.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/26/9f/6c545900fefb7b00ddfa3f16b80d61338a0ec68c31c5451eeeab99082760/langchain_text_splitters-1.1.2.tar.gz", hash = "sha256:782a723db0a4746ac91e251c7c1d57fd23636e4f38ed733074e28d7a86f41627", size = 293580, upload-time = "2026-04-16T14:20:39.162Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/22/d401fffe8d3f1339f6ac880e5d637db73933efa95635304849b2d44ab0fe/langchain_text_splitters-1.1.3.tar.gz", hash = "sha256:929b6c76f99d611a5b1d8f5591ef302909b86a436ceb3217034d24e4757868d8", size = 308295, upload-time = "2026-10-02T15:46:33.173Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/26/1ef06f56198d631296d646a6223de35bcc6cf9795ceb2442816bc963b84c/langchain_text_splitters-1.1.2-py3-none-any.whl", hash = "sha256:a2de0d799ff31886429fd6e2e0032df275b60ec817c19059a7b46181cc1c2f10", size = 35903, upload-time = "2026-04-16T14:20:38.243Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/51/2880d2e88cce13c1180178f7e8dc796c2f45b2dc09cc09ed407d116c08cc/langchain_text_splitters-1.1.3-py3-none-any.whl", hash = "sha256:50edeb318b3be6a6308dddd7d616ab82823a9ccbea59a9c14c58a7b91df60295", size = 38217, upload-time = "2026-10-02T15:46:32.271Z" },
 ]
 
 [[package]]
 name = "langgraph"
-version = "1.2.12"
+version = "1.2.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
@@ -1780,9 +1780,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "xxhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/99/7e/c9e4431adb5eb78d15f0035aae162a113c80d037ceb433ddd78835217848/langgraph-1.2.12.tar.gz", hash = "sha256:5fae9fa4ce771e90f10ff19ce0d5aaef4b41d7632c713d769e89cbce1241a4b9", size = 734541, upload-time = "2026-09-21T14:43:29.684Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/22/75ab5e7d13c842d8dc68f115cf6cc5a651a8d5a993e72a621c98bfb2b1cd/langgraph-1.2.13.tar.gz", hash = "sha256:a3cae71d4cb88455d7a8887109665525aefe4ab13fe941d653cd4b6de2af45c6", size = 752793, upload-time = "2026-10-05T17:51:21.566Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/52/27/5a02054c535ed6fcfb2ab1e5c33c51c810cf1e773194ad28c928f0473509/langgraph-1.2.12-py3-none-any.whl", hash = "sha256:95403af7b510de8d79164742f71daaf866c69ca804a8cb72bef2cc1fa1ab9813", size = 250206, upload-time = "2026-09-21T14:43:28.196Z" },
+    { url = "https://files.pythonhosted.org/packages/da/8e/b7471af7fc72c218e545c74454c386a4b0867a8a15c9893db1d28464f492/langgraph-1.2.13-py3-none-any.whl", hash = "sha256:5d45a021e043aaf39f32122e620eacfd1245aa84dfaa84b0814cef0f4ac78eb4", size = 255979, upload-time = "2026-10-05T17:51:20.221Z" },
 ]
 
 [[package]]

From 9b7e63290109c1c5ccdbe5c5225cb07c77e97f73 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 17:46:19 +0000
Subject: [PATCH 034/245] chore(deps): bump the github-actions group with 2
 updates (#1055)

Bumps the github-actions group with 2 updates: [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain) and [PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml](https://github.com/posthog/posthog-sdk-test-harness).


Updates `dtolnay/rust-toolchain` from 7e38f4b43b4db5c8dd498af069a4f6196df1d067 to e2a55d2ffb04f378e9626c28d38b36d230d1e12f
- [Release notes](https://github.com/dtolnay/rust-toolchain/releases)
- [Commits](https://github.com/dtolnay/rust-toolchain/compare/7e38f4b43b4db5c8dd498af069a4f6196df1d067...e2a55d2ffb04f378e9626c28d38b36d230d1e12f)

Updates `PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml` from 1.11.0 to 1.13.1
- [Release notes](https://github.com/posthog/posthog-sdk-test-harness/releases)
- [Changelog](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/CHANGELOG.md)
- [Commits](https://github.com/posthog/posthog-sdk-test-harness/compare/4593de8b423f61fa222115da592e5c18dc82ad3c...e32f08bd30fab57ce543da5808a668d0fda697b0)

---
updated-dependencies:
- dependency-name: dtolnay/rust-toolchain
  dependency-version: e2a55d2ffb04f378e9626c28d38b36d230d1e12f
  dependency-type: direct:production
  dependency-group: github-actions
- dependency-name: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml
  dependency-version: 1.13.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Dustin Byrne <dustin@posthog.com>
---
 .github/workflows/release.yml        | 4 ++--
 .github/workflows/sdk-compliance.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 7a360cbd4..6987f2f53 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -107,7 +107,7 @@ jobs:
           enable-cache: true
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@7e38f4b43b4db5c8dd498af069a4f6196df1d067
+        uses: dtolnay/rust-toolchain@e2a55d2ffb04f378e9626c28d38b36d230d1e12f
         with:
           toolchain: 1.91.1
           components: cargo
@@ -479,7 +479,7 @@ jobs:
           enable-cache: true
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@7e38f4b43b4db5c8dd498af069a4f6196df1d067
+        uses: dtolnay/rust-toolchain@e2a55d2ffb04f378e9626c28d38b36d230d1e12f
         with:
           toolchain: 1.91.1
           components: cargo
diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index 3891e105c..ad0e0fa71 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -29,7 +29,7 @@ jobs:
 
   compliance:
     name: PostHog SDK compliance tests (capture v0)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@4593de8b423f61fa222115da592e5c18dc82ad3c # 1.11.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@e32f08bd30fab57ce543da5808a668d0fda697b0 # 1.13.1
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
@@ -39,7 +39,7 @@ jobs:
 
   compliance-v1:
     name: PostHog SDK compliance tests (capture v1)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@4593de8b423f61fa222115da592e5c18dc82ad3c # 1.11.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@e32f08bd30fab57ce543da5808a668d0fda697b0 # 1.13.1
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."

From 12e88a254e900e71824aa9fdc95987ec7082c312 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 11:13:16 -0700
Subject: [PATCH 035/245] chore(deps): bump mcp from 1.28.1 to 1.30.0 (#1068)

Bumps [mcp](https://github.com/modelcontextprotocol/python-sdk) from 1.28.1 to 1.30.0.
- [Release notes](https://github.com/modelcontextprotocol/python-sdk/releases)
- [Changelog](https://github.com/modelcontextprotocol/python-sdk/blob/main/RELEASE.md)
- [Commits](https://github.com/modelcontextprotocol/python-sdk/compare/v1.28.1...v1.30.0)

---
updated-dependencies:
- dependency-name: mcp
  dependency-version: 1.30.0
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index c08152be8..6fced805e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2077,7 +2077,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.28.1"
+version = "1.30.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -2095,9 +2095,9 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/93/0142dc84a666daf8ad51a34268f34c12fd6fda4f3810c4be2504eecc8212/mcp-1.30.0.tar.gz", hash = "sha256:445414625fce5c295faa505bb11bacece661ab6f4028d57c935db57820b7a3e4", size = 680511, upload-time = "2026-09-07T14:34:15.845Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
 ]
 
 [[package]]

From 780cba9aeea0d990a65fafe88860905bb4941d81 Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Fri, 16 Oct 2026 11:48:48 -0700
Subject: [PATCH 036/245] fix(integrations): align tracing-header capture
 across frameworks (#1061)

---
 .sampo/changesets/doughty-seer-vellamo.md     |   5 +
 posthog/integrations/_tracing_headers.py      |  62 +++++
 posthog/integrations/asgi.py                  |  60 +++--
 posthog/integrations/django.py                |  81 +++---
 posthog/integrations/flask.py                 |  59 ++---
 .../integrations/test_asgi_integration.py     |  36 ++-
 .../integrations/test_flask_integration.py    |  14 +-
 posthog/test/integrations/test_middleware.py  |   7 +-
 .../test/integrations/test_middleware_api.py  |  19 +-
 .../test/integrations/test_tracing_headers.py | 230 ++++++++++++++++++
 references/middleware_configuration.md        |  37 ++-
 references/public_api_snapshot.txt            |  13 +-
 12 files changed, 479 insertions(+), 144 deletions(-)
 create mode 100644 .sampo/changesets/doughty-seer-vellamo.md
 create mode 100644 posthog/integrations/_tracing_headers.py
 create mode 100644 posthog/test/integrations/test_tracing_headers.py

diff --git a/.sampo/changesets/doughty-seer-vellamo.md b/.sampo/changesets/doughty-seer-vellamo.md
new file mode 100644
index 000000000..d4f66dab3
--- /dev/null
+++ b/.sampo/changesets/doughty-seer-vellamo.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Align ASGI, Flask, and Django tracing-header capture with peer SDKs. Add capture_tracing_headers and POSTHOG_MW_CAPTURE_TRACING_HEADERS, enabled by default once an integration is installed. Keep the trust-named options as deprecated aliases, honor explicit opt-outs, and prefer the capture-named option when both are configured. Share header sanitization and request-context attribution across integrations; explicit capture identity and session properties retain precedence.
diff --git a/posthog/integrations/_tracing_headers.py b/posthog/integrations/_tracing_headers.py
new file mode 100644
index 000000000..084bab609
--- /dev/null
+++ b/posthog/integrations/_tracing_headers.py
@@ -0,0 +1,62 @@
+"""Shared request-scoped analytics attribution for framework integrations."""
+
+import re
+import warnings
+from collections.abc import Callable
+from typing import Optional
+
+from .. import contexts
+
+_CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f-\x9f]")
+_MAX_HEADER_LENGTH = 1000
+
+
+def _sanitize_tracing_header_value(value: object) -> Optional[str]:
+    if not isinstance(value, str):
+        return None
+    return _CONTROL_CHARS_RE.sub("", value).strip()[:_MAX_HEADER_LENGTH] or None
+
+
+def _resolve_capture_tracing_headers(
+    capture: Optional[bool],
+    trust: Optional[bool],
+    *,
+    canonical_name: str = "capture_tracing_headers",
+    deprecated_name: str = "trust_tracing_headers",
+) -> bool:
+    if trust is not None:
+        warnings.warn(
+            f"{deprecated_name} is deprecated; use {canonical_name} instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+    if capture is not None:
+        return capture if isinstance(capture, bool) else False
+    if trust is not None:
+        return trust if isinstance(trust, bool) else False
+    return True
+
+
+def _read_tracing_header(
+    get_header: Callable[[str], object], name: str
+) -> Optional[str]:
+    try:
+        return _sanitize_tracing_header_value(get_header(name))
+    except Exception:
+        return None
+
+
+def _apply_tracing_headers(
+    get_header: Callable[[str], object],
+    capture_tracing_headers: bool,
+    fallback_distinct_id: Optional[str] = None,
+) -> None:
+    distinct_id = fallback_distinct_id
+    if capture_tracing_headers:
+        header_id = _read_tracing_header(get_header, "X-POSTHOG-DISTINCT-ID")
+        session_id = _read_tracing_header(get_header, "X-POSTHOG-SESSION-ID")
+        distinct_id = header_id or distinct_id
+        if session_id:
+            contexts.set_context_session(session_id)
+    if distinct_id:
+        contexts.identify_context(distinct_id)
diff --git a/posthog/integrations/asgi.py b/posthog/integrations/asgi.py
index 670be43ec..5d381c4c0 100644
--- a/posthog/integrations/asgi.py
+++ b/posthog/integrations/asgi.py
@@ -23,9 +23,8 @@
 ``another_client.capture``.
 
 ``X-PostHog-Distinct-ID`` and ``X-PostHog-Session-ID`` are client-controlled
-analytics context, not authentication. They are ignored by default. Set
-``trust_tracing_headers=True`` only when deliberately accepting browser analytics
-attribution or when a trusted upstream strips and replaces incoming values.
+analytics context, not authentication or authorization. They are read by default
+once middleware is installed. Set ``capture_tracing_headers=False`` to ignore them.
 """
 
 import inspect
@@ -39,6 +38,11 @@
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
 )
+from ._tracing_headers import (
+    _apply_tracing_headers,
+    _resolve_capture_tracing_headers,
+    _sanitize_tracing_header_value,
+)
 
 _ASGIApp = Callable[
     [
@@ -92,9 +96,14 @@ def _headers_from_scope(scope: Mapping[str, Any]) -> dict[bytes, bytes]:
             and isinstance(item[0], bytes)
             and isinstance(item[1], bytes)
         ):
-            # Keep the first value. Tracing headers are singular, and joining arbitrary
-            # duplicate user input can create misleading identity values.
-            result.setdefault(item[0].lower(), item[1])
+            name, value = item[0].lower(), item[1]
+            # Tracing headers use the first usable value, never a joined identity.
+            if name in {
+                b"x-posthog-distinct-id",
+                b"x-posthog-session-id",
+            } and not _sanitize_tracing_header_value(value.decode("latin-1")):
+                continue
+            result.setdefault(name, value)
     return result
 
 
@@ -184,11 +193,11 @@ class PosthogASGIMiddleware:
             Returning ``False`` bypasses all instrumentation for that scope.
         extra_properties: Optional sync or async callback receiving the ASGI scope and
             returning additional event properties.
-        trust_tracing_headers: Use client-provided PostHog distinct and session ID
-            headers as analytics context. Disabled by default because these headers
-            are not authenticated. Enable only when deliberately accepting browser
-            attribution or when a trusted upstream replaces incoming values. Never
-            use these identifiers for authorization.
+        capture_tracing_headers: Read PostHog distinct and session ID headers as
+            request-scoped analytics context. Defaults to True. Explicit capture IDs
+            and event properties take precedence. Never use these values for security.
+        trust_tracing_headers: Deprecated alias for ``capture_tracing_headers``.
+            The capture-named option takes precedence when both are supplied.
     """
 
     def __init__(
@@ -198,14 +207,27 @@ def __init__(
         capture_exceptions: Optional[bool] = None,
         request_filter: Optional[_RequestFilter] = None,
         extra_properties: Optional[_ExtraProperties] = None,
-        trust_tracing_headers: bool = False,
+        trust_tracing_headers: Optional[bool] = None,
+        *,
+        capture_tracing_headers: Optional[bool] = None,
     ) -> None:
         self.app = app
         self.client = client
         self.capture_exceptions = capture_exceptions
         self.request_filter = request_filter
         self.extra_properties = extra_properties
-        self.trust_tracing_headers = trust_tracing_headers
+        self.capture_tracing_headers = _resolve_capture_tracing_headers(
+            capture_tracing_headers, trust_tracing_headers
+        )
+
+    @property
+    def trust_tracing_headers(self) -> bool:
+        """Deprecated alias for ``capture_tracing_headers``."""
+        return self.capture_tracing_headers
+
+    @trust_tracing_headers.setter
+    def trust_tracing_headers(self, enabled: bool) -> None:
+        self.capture_tracing_headers = enabled
 
     async def __call__(self, scope, receive, send) -> None:
         if scope.get("type") not in {"http", "websocket"}:
@@ -222,14 +244,10 @@ async def __call__(self, scope, receive, send) -> None:
         # metadata is preserved. The context itself must not capture a second time.
         with contexts.new_context(capture_exceptions=False, client=self.client):
             headers = _headers_from_scope(scope)
-            if self.trust_tracing_headers:
-                session_id = _decode_header(headers.get(b"x-posthog-session-id"))
-                if session_id:
-                    contexts.set_context_session(session_id)
-
-                distinct_id = _decode_header(headers.get(b"x-posthog-distinct-id"))
-                if distinct_id:
-                    contexts.identify_context(distinct_id)
+            _apply_tracing_headers(
+                lambda name: headers.get(name.lower().encode(), b"").decode("latin-1"),
+                self.capture_tracing_headers,
+            )
 
             properties = _extract_properties(scope, headers)
             if self.extra_properties:
diff --git a/posthog/integrations/django.py b/posthog/integrations/django.py
index 7b973c0b7..f241c6cb6 100644
--- a/posthog/integrations/django.py
+++ b/posthog/integrations/django.py
@@ -1,4 +1,3 @@
-import re
 from typing import TYPE_CHECKING, Any, Optional, cast
 
 from .. import contexts
@@ -7,6 +6,7 @@
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
 )
+from ._tracing_headers import _apply_tracing_headers, _resolve_capture_tracing_headers
 
 try:
     from asgiref.sync import iscoroutinefunction, markcoroutinefunction
@@ -27,35 +27,6 @@ def markcoroutinefunction(func):
     from typing import Callable, Dict, Any, Union, Awaitable  # noqa: F401
 
 
-_MAX_TRACING_HEADER_LENGTH = 1000
-_TRACING_HEADER_CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f-\x9f]")
-
-
-def _sanitize_tracing_header_value(value) -> Optional[str]:
-    """Return a safe tracing header value, or None if the value is invalid.
-
-    Tracing headers come from user-controlled HTTP requests and are copied into event properties.
-    Match the PostHog app's header sanitization: accept strings only, remove C0/C1 control
-    characters, trim surrounding whitespace, cap length, and drop empty results.
-    """
-    if not isinstance(value, str) or not value:
-        return None
-
-    return (
-        _TRACING_HEADER_CONTROL_CHARS_RE.sub("", value).strip()[
-            :_MAX_TRACING_HEADER_LENGTH
-        ]
-        or None
-    )
-
-
-def _get_sanitized_tracing_header(request, header_name) -> Optional[str]:
-    try:
-        return _sanitize_tracing_header_value(request.headers.get(header_name))
-    except Exception:
-        return None
-
-
 class PosthogContextMiddleware:
     """Middleware to automatically track Django requests.
 
@@ -78,10 +49,13 @@ class PosthogContextMiddleware:
     - `POSTHOG_MW_REQUEST_FILTER`: a callback receiving the request. Returning `False`
       disables both enrichment and automatic exception capture for that request.
     - `POSTHOG_MW_EXTRA_PROPERTIES`: a callback returning additional event properties.
-    - `POSTHOG_MW_TRUST_TRACING_HEADERS`: accept the client-controlled PostHog identity
-      and session headers only when `True` (default: `False`). These values are analytics
-      context, never authentication or authorization. Authenticated Django user identity
-      is still available when headers are disabled.
+    - `POSTHOG_MW_CAPTURE_TRACING_HEADERS`: read PostHog identity and session headers
+      as request-scoped analytics context (default: `True`). Explicit capture IDs and
+      event properties take precedence. These values are never authentication or
+      authorization. Authenticated Django user identity remains the fallback when no
+      usable header ID is available or header capture is disabled.
+    - `POSTHOG_MW_TRUST_TRACING_HEADERS`: deprecated alias for
+      `POSTHOG_MW_CAPTURE_TRACING_HEADERS`; the capture-named setting takes precedence.
     - `POSTHOG_MW_PROPERTIES_MAP`: an optional callback transforming request properties.
 
     The old `POSTHOG_MW_EXTRA_TAGS` and `POSTHOG_MW_TAG_MAP` settings remain aliases;
@@ -159,11 +133,17 @@ def __init__(self, get_response):
             if capture_exceptions is None or isinstance(capture_exceptions, bool)
             else True
         )
+        capture_tracing_headers = getattr(
+            settings, "POSTHOG_MW_CAPTURE_TRACING_HEADERS", None
+        )
         trust_tracing_headers = getattr(
-            settings, "POSTHOG_MW_TRUST_TRACING_HEADERS", False
+            settings, "POSTHOG_MW_TRUST_TRACING_HEADERS", None
         )
-        self.trust_tracing_headers = (
-            trust_tracing_headers if isinstance(trust_tracing_headers, bool) else False
+        self.capture_tracing_headers = _resolve_capture_tracing_headers(
+            capture_tracing_headers,
+            trust_tracing_headers,
+            canonical_name="POSTHOG_MW_CAPTURE_TRACING_HEADERS",
+            deprecated_name="POSTHOG_MW_TRUST_TRACING_HEADERS",
         )
 
         if hasattr(settings, "POSTHOG_MW_CLIENT") and isinstance(
@@ -173,6 +153,15 @@ def __init__(self, get_response):
         else:
             self.client = None
 
+    @property
+    def trust_tracing_headers(self) -> bool:
+        """Deprecated alias for ``capture_tracing_headers``."""
+        return self.capture_tracing_headers
+
+    @trust_tracing_headers.setter
+    def trust_tracing_headers(self, enabled: bool) -> None:
+        self.capture_tracing_headers = enabled
+
     @property
     def extra_tags(self):
         """Compatibility alias for ``extra_properties``."""
@@ -211,19 +200,11 @@ def _build_tags(self, request, user_id, user_email):
         """
         tags = {}
 
-        # Client-controlled headers are analytics context, not authenticated identity.
-        session_id = None
-        distinct_id = user_id
-        if self.trust_tracing_headers:
-            session_id = _get_sanitized_tracing_header(request, "X-POSTHOG-SESSION-ID")
-            distinct_id = (
-                _get_sanitized_tracing_header(request, "X-POSTHOG-DISTINCT-ID")
-                or user_id
-            )
-        if session_id:
-            contexts.set_context_session(session_id)
-        if distinct_id:
-            contexts.identify_context(distinct_id)
+        _apply_tracing_headers(
+            request.headers.get,
+            self.capture_tracing_headers,
+            fallback_distinct_id=user_id,
+        )
 
         # Extract user email
         if user_email:
diff --git a/posthog/integrations/flask.py b/posthog/integrations/flask.py
index b23b62095..8c416e5dc 100644
--- a/posthog/integrations/flask.py
+++ b/posthog/integrations/flask.py
@@ -19,7 +19,6 @@
 
 from __future__ import annotations
 
-import re
 from contextlib import AbstractContextManager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, cast
@@ -30,6 +29,10 @@
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
 )
+from ._tracing_headers import (
+    _apply_tracing_headers,
+    _resolve_capture_tracing_headers,
+)
 
 if TYPE_CHECKING:
     from flask import Flask, Request
@@ -37,25 +40,10 @@
 
 __all__ = ["PosthogFlaskIntegration"]
 
-_MAX_TRACING_HEADER_LENGTH = 1000
-_TRACING_HEADER_CONTROL_CHARS_RE = re.compile(r"[\x00-\x1f\x7f-\x9f]")
 _EXTENSION_KEY = "posthog"
 _REQUEST_STATE_KEY = "_posthog_integration_state"
 
 
-def _sanitize_tracing_header_value(value: object) -> Optional[str]:
-    """Return a bounded tracing header value safe for event properties."""
-    if not isinstance(value, str) or not value:
-        return None
-
-    return (
-        _TRACING_HEADER_CONTROL_CHARS_RE.sub("", value).strip()[
-            :_MAX_TRACING_HEADER_LENGTH
-        ]
-        or None
-    )
-
-
 @dataclass
 class _RequestState:
     scope: AbstractContextManager[None]
@@ -118,11 +106,11 @@ class PosthogFlaskIntegration:
         extra_properties: Optional callback returning additional event properties.
             This is useful for application-specific metadata such as an authenticated
             user's role. Values should not contain secrets or request bodies.
-        trust_tracing_headers: Use client-provided PostHog distinct and session ID
-            headers as analytics context. Disabled by default because these headers
-            are not authenticated. Enable only when deliberately accepting browser
-            attribution or when a trusted upstream replaces incoming values. Never
-            use these identifiers for authorization.
+        capture_tracing_headers: Read PostHog distinct and session ID headers as
+            request-scoped analytics context. Defaults to True. Explicit capture IDs
+            and event properties take precedence. Never use these values for security.
+        trust_tracing_headers: Deprecated alias for ``capture_tracing_headers``.
+            The capture-named option takes precedence when both are supplied.
 
     The integration intentionally does not capture exceptions handled by an
     application error handler, expected HTTP exceptions, request or response
@@ -139,17 +127,29 @@ def __init__(
         capture_exceptions: Optional[bool] = None,
         request_filter: Optional[Callable[[Request], bool]] = None,
         extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None,
-        trust_tracing_headers: bool = False,
+        trust_tracing_headers: Optional[bool] = None,
+        capture_tracing_headers: Optional[bool] = None,
     ) -> None:
         self.client = client
         self.capture_exceptions = capture_exceptions
         self.request_filter = request_filter
         self.extra_properties = extra_properties
-        self.trust_tracing_headers = trust_tracing_headers
+        self.capture_tracing_headers = _resolve_capture_tracing_headers(
+            capture_tracing_headers, trust_tracing_headers
+        )
 
         if app is not None:
             self.init_app(app)
 
+    @property
+    def trust_tracing_headers(self) -> bool:
+        """Deprecated alias for ``capture_tracing_headers``."""
+        return self.capture_tracing_headers
+
+    @trust_tracing_headers.setter
+    def trust_tracing_headers(self, enabled: bool) -> None:
+        self.capture_tracing_headers = enabled
+
     def init_app(self, app: Flask) -> None:
         """Register the integration with a Flask application once."""
         try:
@@ -190,18 +190,7 @@ def _before_request(self) -> None:
         privacy_settings.apply()
         setattr(g, _REQUEST_STATE_KEY, _RequestState(scope=scope))
 
-        if self.trust_tracing_headers:
-            session_id = _sanitize_tracing_header_value(
-                request.headers.get("X-POSTHOG-SESSION-ID")
-            )
-            if session_id:
-                contexts.set_context_session(session_id)
-
-            distinct_id = _sanitize_tracing_header_value(
-                request.headers.get("X-POSTHOG-DISTINCT-ID")
-            )
-            if distinct_id:
-                contexts.identify_context(distinct_id)
+        _apply_tracing_headers(request.headers.get, self.capture_tracing_headers)
 
         for key, value in self._request_properties(request).items():
             contexts.tag(key, value)
diff --git a/posthog/test/integrations/test_asgi_integration.py b/posthog/test/integrations/test_asgi_integration.py
index 63ddf938e..922f6fcde 100644
--- a/posthog/test/integrations/test_asgi_integration.py
+++ b/posthog/test/integrations/test_asgi_integration.py
@@ -59,7 +59,7 @@ async def send(message):
     with contexts.new_context(fresh=True):
         contexts.identify_context("parent-user")
         contexts.tag("parent-property", "kept")
-        middleware = PosthogASGIMiddleware(app, trust_tracing_headers=True)
+        middleware = PosthogASGIMiddleware(app, capture_tracing_headers=True)
         await middleware(http_scope(method="POST"), noop_receive, send)
 
         assert contexts.get_context_distinct_id() == "parent-user"
@@ -85,14 +85,16 @@ async def send(message):
 
 
 @pytest.mark.asyncio
-async def test_ignores_client_controlled_tracing_headers_by_default():
+async def test_tracing_header_capture_can_be_disabled():
     observed = {}
 
     async def app(scope, receive, send):
         observed["session_id"] = contexts.get_context_session_id()
         observed["distinct_id"] = contexts.get_context_distinct_id()
 
-    await PosthogASGIMiddleware(app)(http_scope(), noop_receive, noop_send)
+    await PosthogASGIMiddleware(app, capture_tracing_headers=False)(
+        http_scope(), noop_receive, noop_send
+    )
 
     assert observed == {"session_id": None, "distinct_id": None}
 
@@ -113,7 +115,7 @@ async def app(scope, receive, send):
             (b"x-posthog-distinct-id", b" user\t-456 "),
         ]
     )
-    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+    await PosthogASGIMiddleware(app, capture_tracing_headers=True)(
         scope, noop_receive, noop_send
     )
 
@@ -122,6 +124,28 @@ async def app(scope, receive, send):
     assert observed["properties"]["$ip"] == "198.51.100.8"
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("first", [b"", b" \t\r\n\x85 ", b"first"])
+async def test_duplicate_tracing_headers_use_first_usable_value(first):
+    observed = {}
+
+    async def app(scope, receive, send):
+        observed["distinct_id"] = contexts.get_context_distinct_id()
+        observed["session_id"] = contexts.get_context_session_id()
+
+    scope = http_scope(
+        headers=[
+            (b"x-posthog-distinct-id", first),
+            (b"X-POSTHOG-DISTINCT-ID", b"second"),
+            (b"x-posthog-session-id", first),
+            (b"X-POSTHOG-SESSION-ID", b"second"),
+        ]
+    )
+    await PosthogASGIMiddleware(app)(scope, noop_receive, noop_send)
+    expected = "first" if first == b"first" else "second"
+    assert observed == {"distinct_id": expected, "session_id": expected}
+
+
 @pytest.mark.asyncio
 async def test_malformed_and_duplicate_headers_are_handled_safely():
     observed = {}
@@ -137,7 +161,7 @@ async def app(scope, receive, send):
             (b"incomplete",),
         ]
     )
-    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+    await PosthogASGIMiddleware(app, capture_tracing_headers=True)(
         scope, noop_receive, noop_send
     )
 
@@ -391,7 +415,7 @@ async def app(scope, receive, send):
         observed["path"] = contexts.get_tags()["$request_path"]
 
     scope = http_scope(type="websocket", scheme="wss", method=None, path="/socket")
-    await PosthogASGIMiddleware(app, trust_tracing_headers=True)(
+    await PosthogASGIMiddleware(app, capture_tracing_headers=True)(
         scope, noop_receive, noop_send
     )
 
diff --git a/posthog/test/integrations/test_flask_integration.py b/posthog/test/integrations/test_flask_integration.py
index 9ce95dd3f..33a116631 100644
--- a/posthog/test/integrations/test_flask_integration.py
+++ b/posthog/test/integrations/test_flask_integration.py
@@ -8,10 +8,8 @@
 import posthog
 from posthog import contexts
 from posthog.client import Client
-from posthog.integrations.flask import (
-    PosthogFlaskIntegration,
-    _sanitize_tracing_header_value,
-)
+from posthog.integrations.flask import PosthogFlaskIntegration
+from posthog.integrations._tracing_headers import _sanitize_tracing_header_value
 
 
 def _app() -> Flask:
@@ -25,7 +23,7 @@ def test_adds_request_context_and_restores_parent_context() -> None:
     PosthogFlaskIntegration(
         app,
         extra_properties=lambda request: {"tenant": "acme"},
-        trust_tracing_headers=True,
+        capture_tracing_headers=True,
     )
 
     @app.get("/users/<user_id>")
@@ -319,10 +317,10 @@ def capture_event():
     exception_client.capture.assert_not_called()
 
 
-def test_tracing_headers_are_ignored_by_default_and_can_be_trusted() -> None:
-    def request_identity(trust_tracing_headers: bool) -> dict:
+def test_tracing_header_capture_can_be_disabled() -> None:
+    def request_identity(capture_tracing_headers: bool) -> dict:
         app = _app()
-        PosthogFlaskIntegration(app, trust_tracing_headers=trust_tracing_headers)
+        PosthogFlaskIntegration(app, capture_tracing_headers=capture_tracing_headers)
 
         @app.get("/identity")
         def identity():
diff --git a/posthog/test/integrations/test_middleware.py b/posthog/test/integrations/test_middleware.py
index d58065bf3..336d7e017 100644
--- a/posthog/test/integrations/test_middleware.py
+++ b/posthog/test/integrations/test_middleware.py
@@ -56,7 +56,7 @@ def create_middleware(
         tag_map=None,
         capture_exceptions=True,
         get_response=None,
-        trust_tracing_headers=True,
+        capture_tracing_headers=True,
     ):
         """Helper to create middleware instance with mock Django settings"""
         if get_response is None:
@@ -69,7 +69,8 @@ def create_middleware(
             mock_settings.POSTHOG_MW_TAG_MAP = tag_map
             mock_settings.POSTHOG_MW_CAPTURE_EXCEPTIONS = capture_exceptions
             mock_settings.POSTHOG_MW_CLIENT = None
-            mock_settings.POSTHOG_MW_TRUST_TRACING_HEADERS = trust_tracing_headers
+            mock_settings.POSTHOG_MW_CAPTURE_TRACING_HEADERS = capture_tracing_headers
+            mock_settings.POSTHOG_MW_TRUST_TRACING_HEADERS = None
 
             # Make hasattr work correctly
             def mock_hasattr(obj, name):
@@ -474,7 +475,7 @@ class TestPosthogContextMiddlewareAsync(unittest.TestCase):
 
     def setUp(self):
         # Header propagation tests explicitly opt in to analytics attribution.
-        configuration = override_settings(POSTHOG_MW_TRUST_TRACING_HEADERS=True)
+        configuration = override_settings(POSTHOG_MW_CAPTURE_TRACING_HEADERS=True)
         configuration.enable()
         self.addCleanup(configuration.disable)
 
diff --git a/posthog/test/integrations/test_middleware_api.py b/posthog/test/integrations/test_middleware_api.py
index 7d3ccc754..af68247a7 100644
--- a/posthog/test/integrations/test_middleware_api.py
+++ b/posthog/test/integrations/test_middleware_api.py
@@ -89,8 +89,9 @@ def test_omitted_capture_setting_preserves_legacy_default():
 
 
 @pytest.mark.parametrize("asynchronous", [False, True])
-@pytest.mark.parametrize("trust", [False, True])
-def test_tracing_headers_require_opt_in_and_user_fallback(asynchronous, trust):
+@pytest.mark.parametrize("capture", [None, False, True])
+@pytest.mark.parametrize("header_id", ["browser-user", " \r\n ", None])
+def test_tracing_header_capture_and_user_fallback(asynchronous, capture, header_id):
     observed = {}
 
     def view(request):
@@ -103,7 +104,7 @@ async def async_view(request):
 
     request = MockRequest(
         headers={
-            "X-POSTHOG-DISTINCT-ID": "browser-user",
+            "X-POSTHOG-DISTINCT-ID": header_id,
             "X-POSTHOG-SESSION-ID": "browser-session",
         }
     )
@@ -113,18 +114,18 @@ async def auser():
         return request.user
 
     request.auser = auser
-    with override_settings(
-        POSTHOG_MW_CAPTURE_EXCEPTIONS=False,
-        POSTHOG_MW_TRUST_TRACING_HEADERS=trust,
-    ):
+    options = {} if capture is None else {"POSTHOG_MW_CAPTURE_TRACING_HEADERS": capture}
+    with override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=False, **options):
         middleware = PosthogContextMiddleware(async_view if asynchronous else view)
         with contexts.new_context(fresh=True, capture_exceptions=False):
             result = middleware(request)
             assert (asyncio.run(result) if asynchronous else result) == "response"
 
     assert observed == {
-        "distinct_id": "browser-user" if trust else "42",
-        "session_id": "browser-session" if trust else None,
+        "distinct_id": "browser-user"
+        if capture is not False and header_id == "browser-user"
+        else "42",
+        "session_id": "browser-session" if capture is not False else None,
     }
 
 
diff --git a/posthog/test/integrations/test_tracing_headers.py b/posthog/test/integrations/test_tracing_headers.py
new file mode 100644
index 000000000..39edf7c21
--- /dev/null
+++ b/posthog/test/integrations/test_tracing_headers.py
@@ -0,0 +1,230 @@
+"""Shared tracing-header contract through each framework's public entry point."""
+
+from unittest.mock import Mock, patch
+from uuid import UUID
+
+import pytest
+import django
+from django.conf import settings as django_settings
+from django.test import RequestFactory, override_settings
+from flask import Flask
+
+from posthog import contexts
+from posthog.client import Client
+from posthog.integrations.asgi import PosthogASGIMiddleware
+from posthog.integrations.django import PosthogContextMiddleware
+from posthog.integrations.flask import PosthogFlaskIntegration
+
+
+@pytest.fixture(params=["asgi", "django", "django-async", "flask"])
+def run_request(request):
+    if not django_settings.configured:
+        django_settings.configure(SECRET_KEY="test-secret", INSTALLED_APPS=[])
+        django.setup()
+
+    async def run(callback, headers=None, **options):
+        headers = headers or {}
+        if request.param == "asgi":
+
+            async def app(scope, receive, send):
+                callback()
+
+            scope = {
+                "type": "http",
+                "headers": [
+                    (k.encode(), v.encode("latin-1")) for k, v in headers.items()
+                ],
+            }
+            await PosthogASGIMiddleware(app, **options)(scope, Mock(), Mock())
+        elif request.param.startswith("django"):
+
+            def view(request):
+                callback()
+                return "response"
+
+            async def async_view(request):
+                return view(request)
+
+            settings = {"POSTHOG_MW_" + k.upper(): v for k, v in options.items()}
+            with override_settings(
+                POSTHOG_MW_CAPTURE_EXCEPTIONS=False,
+                ALLOWED_HOSTS=["testserver"],
+                **settings,
+            ):
+                middleware = PosthogContextMiddleware(
+                    async_view if request.param == "django-async" else view
+                )
+                result = middleware(RequestFactory().get("/", headers=headers))
+                if request.param == "django-async":
+                    await result
+        else:
+            app = Flask(__name__)
+            PosthogFlaskIntegration(app, **options)
+
+            @app.get("/")
+            def view():
+                callback()
+                return "response"
+
+            # WSGI values can contain controls even though Werkzeug's header builder
+            # rejects them. Exercise the integration's own sanitization as well.
+            environ = {
+                "HTTP_" + k.upper().replace("-", "_"): v for k, v in headers.items()
+            }
+            assert (
+                app.test_client().get("/", environ_overrides=environ).status_code == 200
+            )
+
+    return run
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("enabled", [None, False, True])
+async def test_capture_tracing_headers_configuration(run_request, enabled):
+    observed = []
+    options = {} if enabled is None else {"capture_tracing_headers": enabled}
+    await run_request(
+        lambda: observed.append(
+            (contexts.get_context_distinct_id(), contexts.get_context_session_id())
+        ),
+        {"x-Posthog-Distinct-ID": "browser", "X-posthog-SESSION-id": "session"},
+        **options,
+    )
+    assert observed == (
+        [(None, None)] if enabled is False else [("browser", "session")]
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("legacy", [False, True])
+@pytest.mark.parametrize("canonical", [None, False, True])
+async def test_deprecated_alias_and_canonical_precedence(
+    run_request, legacy, canonical
+):
+    observed = []
+    options = {"trust_tracing_headers": legacy}
+    if canonical is not None:
+        options["capture_tracing_headers"] = canonical
+    with pytest.warns(
+        DeprecationWarning, match="CAPTURE_TRACING_HEADERS|capture_tracing_headers"
+    ):
+        await run_request(
+            lambda: observed.append(contexts.get_context_distinct_id()),
+            {"X-PostHog-Distinct-ID": "browser"},
+            **options,
+        )
+    assert observed == (
+        ["browser"] if (legacy if canonical is None else canonical) else [None]
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "value, expected",
+    [("  user\n-\t1\x85  ", "user-1"), ("x" * 1001, "x" * 1000), (" \r\n ", None)],
+)
+async def test_sanitization_is_identical(run_request, value, expected):
+    observed = []
+    await run_request(
+        lambda: observed.append(
+            (contexts.get_context_distinct_id(), contexts.get_context_session_id())
+        ),
+        {"X-PostHog-Distinct-ID": value, "X-PostHog-Session-ID": value},
+    )
+    assert observed == [(expected, expected)]
+
+
+@pytest.fixture
+def client():
+    instance = Client("test-key", send=False)
+    yield instance
+    instance.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_explicit_capture_values_override_headers(run_request, client):
+    with patch.object(client, "_enqueue") as enqueue:
+
+        def capture():
+            client.capture("implicit")
+            client.capture(
+                "explicit",
+                distinct_id="explicit-user",
+                properties={"$session_id": "explicit-session"},
+            )
+            contexts.identify_context("application-user")
+            client.capture("application")
+
+        await run_request(
+            capture,
+            {
+                "X-PostHog-Distinct-ID": "header-user",
+                "X-PostHog-Session-ID": "header-session",
+            },
+        )
+    messages = [call.args[0] for call in enqueue.call_args_list]
+    assert [m["distinct_id"] for m in messages] == [
+        "header-user",
+        "explicit-user",
+        "application-user",
+    ]
+    assert [m["properties"]["$session_id"] for m in messages] == [
+        "header-session",
+        "explicit-session",
+        "header-session",
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("process_person_profile", [None, False, True])
+async def test_session_only_capture_is_personless_and_flags_are_empty(
+    run_request, client, process_person_profile
+):
+    with (
+        patch.object(client, "_enqueue") as enqueue,
+        patch("requests.Session.request") as network,
+    ):
+
+        def capture():
+            properties = (
+                {}
+                if process_person_profile is None
+                else {"$process_person_profile": process_person_profile}
+            )
+            client.capture("session-only", properties=properties)
+            flags = client.evaluate_flags()
+            assert flags.is_enabled("unknown") is False
+            assert flags.get_flag("unknown") is None
+
+        await run_request(capture, {"X-PostHog-Session-ID": "header-session"})
+        network.assert_not_called()
+    enqueue.assert_called_once()
+    event = enqueue.call_args.args[0]
+    assert UUID(event["distinct_id"])
+    assert event["properties"]["$session_id"] == "header-session"
+    assert event["properties"]["$process_person_profile"] is (
+        process_person_profile if process_person_profile is not None else False
+    )
+
+
+@pytest.mark.asyncio
+async def test_request_context_is_restored_and_not_reused(run_request):
+    observed = []
+
+    def observe():
+        observed.append(
+            (contexts.get_context_distinct_id(), contexts.get_context_session_id())
+        )
+
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        await run_request(
+            observe,
+            {
+                "X-PostHog-Distinct-ID": "first-user",
+                "X-PostHog-Session-ID": "first-session",
+            },
+        )
+        assert contexts.get_context_distinct_id() is None
+        assert contexts.get_context_session_id() is None
+        await run_request(observe)
+    assert observed == [("first-user", "first-session"), (None, None)]
diff --git a/references/middleware_configuration.md b/references/middleware_configuration.md
index 1612117d4..2a065adaa 100644
--- a/references/middleware_configuration.md
+++ b/references/middleware_configuration.md
@@ -12,7 +12,7 @@ request event or redirect manually captured events to a different client.
 | `capture_exceptions` | `POSTHOG_MW_CAPTURE_EXCEPTIONS` | `True`: capture automatically; `False`: context only; `None`: inherit the effective client's `enable_exception_autocapture`. |
 | `request_filter` | `POSTHOG_MW_REQUEST_FILTER` | Callback returning `False` to skip both enrichment and automatic capture for a request. |
 | `extra_properties` | `POSTHOG_MW_EXTRA_PROPERTIES` | Callback returning additional event properties. Explicit properties passed to event capture take precedence. |
-| `trust_tracing_headers` | `POSTHOG_MW_TRUST_TRACING_HEADERS` | Accept `X-PostHog-Distinct-ID` and `X-PostHog-Session-ID` only when `True`; defaults to `False`. |
+| `capture_tracing_headers` | `POSTHOG_MW_CAPTURE_TRACING_HEADERS` | Read `X-PostHog-Distinct-ID` and `X-PostHog-Session-ID` into request-scoped analytics context; defaults to `True` once the integration is installed. |
 
 ASGI callbacks receive the ASGI scope and can be synchronous or asynchronous.
 Flask callbacks receive the Flask request. Django callbacks receive the Django
@@ -38,12 +38,35 @@ old and new settings are present, the new setting takes precedence (including
 when set to `None` to disable the callback). Existing tag-named middleware methods
 and attributes remain compatibility aliases.
 
-Tracing headers now require opt-in in Django and Flask, matching ASGI's secure
-default. Applications intentionally relying on browser-to-backend analytics
-attribution must enable the trust option. Sanitization limits malformed input;
-it does not establish authenticity. Never use these headers for authentication or
-authorization. Django can still use its authenticated request user as identity
-when tracing headers are ignored.
+## Tracing headers
+
+All three integrations capture tracing headers by default once installed. Disable
+extraction with `capture_tracing_headers=False`, or
+`POSTHOG_MW_CAPTURE_TRACING_HEADERS = False` in Django. This does not disable request
+metadata or automatic exception capture.
+
+`trust_tracing_headers` and `POSTHOG_MW_TRUST_TRACING_HEADERS` remain deprecated
+aliases and emit `DeprecationWarning` when configured. Explicit `False` on either
+alias continues to disable extraction. The capture-named option takes precedence
+when both names are supplied; `None` means the option was not supplied.
+
+Header names are case-insensitive. Values must be strings; control characters are
+removed, surrounding whitespace is trimmed, and values are capped at 1000
+characters. Empty or invalid values are ignored. Repeated ASGI tracing headers use
+the first usable value rather than combining identities. A usable header distinct ID
+sets the request context identity, replacing inherited context identity; Django
+falls back to its authenticated request user ID when no usable header ID is
+available or extraction is disabled. A usable session header sets the context
+session and is attached to captured events as `$session_id`.
+
+Explicit per-call distinct IDs and event properties, including `$session_id`,
+always take precedence over header-derived context. Application code may also
+replace request context identity with `identify_context`. Context changes remain
+request-local and are restored when request handling ends.
+
+These headers are client-controlled analytics context, never authentication or
+authorization evidence. Sanitization limits malformed input; it does not establish
+authenticity.
 
 ## Django REST Framework
 
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index b66a265f1..29a1c477e 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -867,10 +867,11 @@ attribute posthog.host = None
 attribute posthog.in_app_modules = None
 attribute posthog.integrations.asgi.PosthogASGIMiddleware.app = app
 attribute posthog.integrations.asgi.PosthogASGIMiddleware.capture_exceptions = capture_exceptions
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
 attribute posthog.integrations.asgi.PosthogASGIMiddleware.client = client
 attribute posthog.integrations.asgi.PosthogASGIMiddleware.extra_properties = extra_properties
 attribute posthog.integrations.asgi.PosthogASGIMiddleware.request_filter = request_filter
-attribute posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers = trust_tracing_headers
+attribute posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers: bool
 attribute posthog.integrations.celery.PosthogCeleryIntegration.capture_exceptions = capture_exceptions
 attribute posthog.integrations.celery.PosthogCeleryIntegration.capture_task_lifecycle_events = capture_task_lifecycle_events
 attribute posthog.integrations.celery.PosthogCeleryIntegration.client = client
@@ -878,6 +879,7 @@ attribute posthog.integrations.celery.PosthogCeleryIntegration.propagate_context
 attribute posthog.integrations.celery.PosthogCeleryIntegration.task_filter = task_filter
 attribute posthog.integrations.django.PosthogContextMiddleware.async_capable = True
 attribute posthog.integrations.django.PosthogContextMiddleware.capture_exceptions: Optional[bool] = capture_exceptions if (capture_exceptions is None or isinstance(capture_exceptions, bool)) else True
+attribute posthog.integrations.django.PosthogContextMiddleware.capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers, canonical_name='POSTHOG_MW_CAPTURE_TRACING_HEADERS', deprecated_name='POSTHOG_MW_TRUST_TRACING_HEADERS')
 attribute posthog.integrations.django.PosthogContextMiddleware.client = cast('Optional[Client]', settings.POSTHOG_MW_CLIENT)
 attribute posthog.integrations.django.PosthogContextMiddleware.extra_properties = cast('Callable[[HttpRequest], Dict[str, Any]]', extra_properties) if callable(extra_properties) else None
 attribute posthog.integrations.django.PosthogContextMiddleware.extra_tags
@@ -886,12 +888,13 @@ attribute posthog.integrations.django.PosthogContextMiddleware.properties_map =
 attribute posthog.integrations.django.PosthogContextMiddleware.request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
 attribute posthog.integrations.django.PosthogContextMiddleware.sync_capable = True
 attribute posthog.integrations.django.PosthogContextMiddleware.tag_map
-attribute posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers = trust_tracing_headers if isinstance(trust_tracing_headers, bool) else False
+attribute posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers: bool
 attribute posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions = capture_exceptions
+attribute posthog.integrations.flask.PosthogFlaskIntegration.capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
 attribute posthog.integrations.flask.PosthogFlaskIntegration.client = client
 attribute posthog.integrations.flask.PosthogFlaskIntegration.extra_properties = extra_properties
 attribute posthog.integrations.flask.PosthogFlaskIntegration.request_filter = request_filter
-attribute posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers = trust_tracing_headers
+attribute posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers: bool
 attribute posthog.is_server = True
 attribute posthog.log_captured_exceptions = False
 attribute posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware.app = app
@@ -1217,10 +1220,10 @@ class posthog.feature_flags.InconclusiveMatchError
 class posthog.feature_flags.RequiresServerEvaluation 
 class posthog.flag_definition_cache.FlagDefinitionCacheData 
 class posthog.flag_definition_cache.FlagDefinitionCacheProvider 
-class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: bool = False)
+class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: Optional[bool] = None, *, capture_tracing_headers: Optional[bool] = None)
 class posthog.integrations.celery.PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
 class posthog.integrations.django.PosthogContextMiddleware(get_response)
-class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: bool = False)
+class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None)
 class posthog.mcp.McpAnalytics(key: Any)
 class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any)
 class posthog.mcp.constants.PostHogMCPAnalyticsEvent 

From d0b6f7127f6d60a17d1c67724ad5eb50d12a7dd6 Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:21:48 +0700
Subject: [PATCH 037/245] docs: clarify reusable flush and terminal shutdown
 guidance (#1043)

* docs: clarify reusable flush and terminal shutdown guidance

* docs: preserve published 7.67.0 reference snapshot
---
 .../flush-shutdown-lifetime-guidance.md       |  5 ++
 posthog/__init__.py                           | 47 ++++++++++++---
 posthog/client.py                             | 60 +++++++++++++------
 .../posthog-python-references-latest.json     | 16 ++---
 4 files changed, 95 insertions(+), 33 deletions(-)
 create mode 100644 .sampo/changesets/flush-shutdown-lifetime-guidance.md

diff --git a/.sampo/changesets/flush-shutdown-lifetime-guidance.md b/.sampo/changesets/flush-shutdown-lifetime-guidance.md
new file mode 100644
index 000000000..a87fd12bf
--- /dev/null
+++ b/.sampo/changesets/flush-shutdown-lifetime-guidance.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Clarify when to flush reusable clients versus shut down disposable clients, including timeout and delivery limitations.
diff --git a/posthog/__init__.py b/posthog/__init__.py
index d718906f0..66fb9ea19 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -1226,16 +1226,39 @@ def load_feature_flags():
 
 def flush(timeout_seconds: Optional[float] = 10) -> None:
     """
-    Tell the client to flush all queued events.
+    Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.
+
+    Call ``flush()`` before a short-lived request or serverless invocation returns
+    when using the shared module-level client. Use ``shutdown()`` only for final
+    process cleanup or a client that will not be reused. Flush does not stop the
+    background workers or feature flag poller, and does not end open spans.
+
+    Returning does not guarantee server receipt: pending work can remain after a
+    timeout or span export failure, and failed events may be dropped by consumers.
+    Calls made directly from SDK callbacks such as ``on_error`` are deferred
+    rather than blocking the worker that invoked the callback.
 
     Args:
-        timeout_seconds: Maximum seconds to wait for the queue to flush.
-            Defaults to 10 seconds. Pass ``None`` to wait indefinitely.
+        timeout_seconds: Seconds to wait for event queues to drain, shared across
+            event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a
+            time limit; this does not guarantee successful delivery. Queued spans
+            flush concurrently, waiting up to this many seconds for an in-flight
+            flush before starting a fresh drain budget. A lock wait timeout leaves
+            the in-flight flush to finish. At least one span request is attempted
+            after acquiring the lock, even with no budget left; retriable failures
+            are retried after backoff while budget remains, with one last attempt
+            at the deadline. The last span request is not cut short and is bounded
+            by the client's ``timeout`` in seconds,
+            so this is not a strict wall-clock limit for the whole call. With
+            ``None``, a retriable span failure is left for a later flush rather than
+            retried within this call.
 
     Examples:
         ```python
-        from posthog import flush
-        flush()
+        import posthog
+        posthog.capture('event_name', distinct_id='user_id')
+        # Before a serverless invocation returns; keep the global client open.
+        posthog.flush(timeout_seconds=10)
         ```
 
     Category:
@@ -1343,11 +1366,21 @@ def get_active_span() -> Optional[Span]:
 
 def shutdown() -> None:
     """
-    Flush all messages and cleanly shutdown the client.
+    Attempt final delivery and permanently shut down the global client.
+
+    Call this for final process cleanup, not at the end of each request or
+    serverless invocation that shares the module-level client. Use ``flush()``
+    before returning from those invocations instead. Shutdown closes capture
+    lanes, stops background workers and the feature flag poller, and tears down
+    integrations. The global client is not recreated automatically after shutdown.
 
     This normally blocks until queued events have been attempted and cleanup
     finishes. Failed or undrainable events may be dropped and reported through
-    logging or ``on_error``; returning does not guarantee server receipt.
+    logging or ``on_error``; returning does not guarantee server receipt. Event
+    draining has no timeout. Queued spans get a final flush with up to 30 seconds
+    waiting for an in-flight flush, then a fresh 30-second drain budget; the last
+    HTTP request is not cut short. Unsent queued spans and still-open spans are
+    discarded with a warning.
     Lifecycle cleanup is attempted once, and cleanup failures are logged without
     retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred
     to avoid deadlocking the worker. If blocking completion is required, signal an application-owned
diff --git a/posthog/client.py b/posthog/client.py
index d74ea56e3..2f33a29ae 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -2715,25 +2715,41 @@ def get_active_span(self) -> Optional[Span]:
 
     def flush(self, timeout_seconds: Optional[float] = 10) -> None:
         """
-        Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.
+        Attempt immediate delivery of queued events and ended spans, keeping the client reusable.
+
+        For a client shared across requests or serverless invocations (including
+        the module-level client), call ``flush()`` before a short-lived invocation
+        returns. Use ``shutdown()`` instead only for final process cleanup or when
+        disposing of a client that will not be reused. Flush does not stop the
+        background workers or feature flag poller, and does not end open spans.
+
+        Returning does not guarantee server receipt: pending work can remain after
+        a timeout or span export failure, and failed events may be dropped by the
+        consumers. Calls made directly from SDK callbacks such as ``on_error`` are
+        deferred rather than blocking the worker that invoked the callback.
 
         Args:
-            timeout_seconds: Maximum seconds to wait for the queue to flush.
-                Defaults to 10 seconds. Pass ``None`` to wait indefinitely.
-                Queued spans are sent at the same time, within the same
-                budget: at least one span request is attempted even when the
-                budget is already spent, a retriable failure is retried after
-                its backoff while budget remains, no other request starts once
-                it is spent, and each request is bounded by ``timeout``. The
-                wait for the last request is not cut short, so a flush can
-                take up to ``timeout_seconds`` plus ``timeout`` in the worst
-                case. A span flush already in flight for the whole wait is
-                left to finish instead.
+            timeout_seconds: Seconds to wait for event queues to drain, shared
+                across event lanes. Defaults to 10 seconds. Pass ``None`` to wait
+                without a time limit; this does not guarantee successful delivery.
+                Queued spans flush concurrently. The span exporter waits up to
+                this many seconds for an in-flight flush, then uses a fresh drain
+                budget once it acquires the lock. If the lock wait times out, the
+                in-flight flush is left to finish. At least one span request is
+                attempted after acquiring the lock, even with no budget left;
+                retriable failures are retried after backoff while budget remains,
+                with one last attempt at the deadline. Each span request is
+                bounded by the client's ``timeout`` in
+                seconds, and the last request is not cut short. This is therefore
+                not a strict wall-clock limit for the whole call. With ``None``,
+                a retriable span failure is left for a later flush rather than
+                retried within this call.
 
         Examples:
             ```python
-            posthog.capture('event_name')
-            posthog.flush()  # Ensures the event is sent immediately
+            posthog.capture('event_name', distinct_id='user_id')
+            # Before a serverless invocation returns; keep the shared client open.
+            posthog.flush(timeout_seconds=10)
             ```
         """
         if self._defer_flush_from_callback(timeout_seconds):
@@ -3130,14 +3146,22 @@ def join(self) -> None:
     @no_throw()
     def shutdown(self) -> None:
         """
-        Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.
+        Attempt final delivery and permanently shut down the client.
+
+        Call this for final process cleanup or when disposing of a client that
+        will not be reused. It closes capture lanes, stops background workers and
+        the feature flag poller, and tears down integrations. Do not call it at the
+        end of each request or serverless invocation when the client is shared;
+        call ``flush()`` before returning instead. A shut-down client cannot be
+        reused; create a new client if needed.
 
         Normally this method blocks until queued events have been attempted and
         cleanup finishes. Failed or undrainable events may be dropped and
         reported through logging or ``on_error``; returning does not guarantee
-        server receipt. Queued spans get one final flush of up to 30 s (plus a
-        request already in flight); any it cannot send are discarded with a
-        warning, as are spans still open.
+        server receipt. Event draining has no timeout. Queued spans get one final
+        flush with up to 30 seconds waiting for an in-flight flush, then a fresh
+        30-second drain budget; the last HTTP request is not cut short. Any spans
+        it cannot send are discarded with a warning, as are spans still open.
         Lifecycle cleanup is attempted once, and cleanup failures
         are logged without retry. When called directly from an SDK callback such as
         ``on_error``, shutdown is deferred to avoid blocking the worker that
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 598946836..4e5e75c7c 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -1001,13 +1001,13 @@
         {
           "id": "flush",
           "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
           "details": "",
           "category": null,
           "params": [
             {
               "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
               "isOptional": true,
               "type": "float"
             }
@@ -1022,7 +1022,7 @@
             {
               "id": "example_1",
               "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
             }
           ]
         },
@@ -2050,7 +2050,7 @@
         {
           "id": "shutdown",
           "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
           "details": "",
           "category": null,
           "params": [],
@@ -2489,13 +2489,13 @@
         {
           "id": "flush",
           "title": "flush",
-          "description": "Tell the client to flush all queued events.",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
           "details": "",
           "category": "Client management",
           "params": [
             {
               "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
               "isOptional": true,
               "type": "float"
             }
@@ -2510,7 +2510,7 @@
             {
               "id": "example_1",
               "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
             }
           ]
         },
@@ -3421,7 +3421,7 @@
         {
           "id": "shutdown",
           "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
           "details": "",
           "category": "Client management",
           "params": [],

From 20a574ec0d723a2228f51d3a1d63b44ecaf343d4 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 19:23:37 +0000
Subject: [PATCH 038/245] chore: Release v7.71.0 [skip ci]

---
 .sampo/changesets/doughty-seer-vellamo.md             |  5 -----
 .sampo/changesets/flush-shutdown-lifetime-guidance.md |  5 -----
 openfeature-provider/CHANGELOG.md                     |  6 ++++++
 openfeature-provider/pyproject.toml                   |  2 +-
 posthog/CHANGELOG.md                                  | 10 ++++++++++
 posthog/version.py                                    |  2 +-
 pyproject.toml                                        |  2 +-
 uv.lock                                               |  4 ++--
 8 files changed, 21 insertions(+), 15 deletions(-)
 delete mode 100644 .sampo/changesets/doughty-seer-vellamo.md
 delete mode 100644 .sampo/changesets/flush-shutdown-lifetime-guidance.md

diff --git a/.sampo/changesets/doughty-seer-vellamo.md b/.sampo/changesets/doughty-seer-vellamo.md
deleted file mode 100644
index d4f66dab3..000000000
--- a/.sampo/changesets/doughty-seer-vellamo.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Align ASGI, Flask, and Django tracing-header capture with peer SDKs. Add capture_tracing_headers and POSTHOG_MW_CAPTURE_TRACING_HEADERS, enabled by default once an integration is installed. Keep the trust-named options as deprecated aliases, honor explicit opt-outs, and prefer the capture-named option when both are configured. Share header sanitization and request-context attribution across integrations; explicit capture identity and session properties retain precedence.
diff --git a/.sampo/changesets/flush-shutdown-lifetime-guidance.md b/.sampo/changesets/flush-shutdown-lifetime-guidance.md
deleted file mode 100644
index a87fd12bf..000000000
--- a/.sampo/changesets/flush-shutdown-lifetime-guidance.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Clarify when to flush reusable clients versus shut down disposable clients, including timeout and delivery limitations.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 9ec2bd183..0a671dafb 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.107 — 2026-10-16
+
+### Patch changes
+
+- Updated dependencies: posthog@7.71.0
+
 ## 0.1.106 — 2026-10-15
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3bb79a00d..6bcc7ae10 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.106"
+version = "0.1.107"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 1e1e76b84..1baddc69b 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,15 @@
 # posthog
 
+## 7.71.0 — 2026-10-16
+
+### Minor changes
+
+- [780cba9](https://github.com/posthog/posthog-python/commit/780cba9aeea0d990a65fafe88860905bb4941d81) Align ASGI, Flask, and Django tracing-header capture with peer SDKs. Add capture_tracing_headers and POSTHOG_MW_CAPTURE_TRACING_HEADERS, enabled by default once an integration is installed. Keep the trust-named options as deprecated aliases, honor explicit opt-outs, and prefer the capture-named option when both are configured. Share header sanitization and request-context attribution across integrations; explicit capture identity and session properties retain precedence. — Thanks @dustinbyrne!
+
+### Patch changes
+
+- [d0b6f71](https://github.com/posthog/posthog-python/commit/d0b6f7127f6d60a17d1c67724ad5eb50d12a7dd6) Clarify when to flush reusable clients versus shut down disposable clients, including timeout and delivery limitations. — Thanks @marandaneto!
+
 ## 7.70.2 — 2026-10-15
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index c4ce44e4d..08106028b 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.70.2"
+VERSION = "7.71.0"
diff --git a/pyproject.toml b/pyproject.toml
index fab4ae8b1..44e84c33a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.70.2"
+version = "7.71.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 6fced805e..a34a6d808 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2499,7 +2499,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.106"
+version = "0.1.107"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2829,7 +2829,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.2"
+version = "7.71.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 883eacaba876dfc7d50febbf44b791470df7cc51 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 19:23:43 +0000
Subject: [PATCH 039/245] Update generated references

---
 .../posthog-python-references-7.71.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.71.0.json

diff --git a/references/posthog-python-references-7.71.0.json b/references/posthog-python-references-7.71.0.json
new file mode 100644
index 000000000..342930ffc
--- /dev/null
+++ b/references/posthog-python-references-7.71.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.71.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 4e5e75c7c..342930ffc 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.70.2",
+    "version": "7.71.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b1363dc5e20c46f6a2c7f33cbf586fd9c302d80b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 13:45:35 -0700
Subject: [PATCH 040/245] chore(deps): bump the uv group across 4 directories
 with 2 updates (#1069)

Bumps the uv group with 1 update in the /examples/example-ai-llamaindex directory: [tinytag](https://github.com/tinytag/tinytag).
Bumps the uv group with 1 update in the /examples/example-ai-openai-agents directory: [mcp](https://github.com/modelcontextprotocol/python-sdk).
Bumps the uv group with 1 update in the /examples/example-ai-pydantic-ai directory: [mcp](https://github.com/modelcontextprotocol/python-sdk).
Bumps the uv group with 1 update in the /examples/example-ai-semantic-kernel directory: [mcp](https://github.com/modelcontextprotocol/python-sdk).


Updates `tinytag` from 2.2.1 to 2.3.0
- [Release notes](https://github.com/tinytag/tinytag/releases)
- [Commits](https://github.com/tinytag/tinytag/compare/2.2.1...2.3.0)

Updates `mcp` from 1.28.1 to 1.30.0
- [Release notes](https://github.com/modelcontextprotocol/python-sdk/releases)
- [Changelog](https://github.com/modelcontextprotocol/python-sdk/blob/main/RELEASE.md)
- [Commits](https://github.com/modelcontextprotocol/python-sdk/compare/v1.28.1...v1.30.0)

Updates `mcp` from 1.29.1 to 1.30.0
- [Release notes](https://github.com/modelcontextprotocol/python-sdk/releases)
- [Changelog](https://github.com/modelcontextprotocol/python-sdk/blob/main/RELEASE.md)
- [Commits](https://github.com/modelcontextprotocol/python-sdk/compare/v1.28.1...v1.30.0)

Updates `mcp` from 2.1.1 to 2.2.0
- [Release notes](https://github.com/modelcontextprotocol/python-sdk/releases)
- [Changelog](https://github.com/modelcontextprotocol/python-sdk/blob/main/RELEASE.md)
- [Commits](https://github.com/modelcontextprotocol/python-sdk/compare/v1.28.1...v1.30.0)

---
updated-dependencies:
- dependency-name: tinytag
  dependency-version: 2.3.0
  dependency-type: indirect
  dependency-group: uv
- dependency-name: mcp
  dependency-version: 1.30.0
  dependency-type: indirect
  dependency-group: uv
- dependency-name: mcp
  dependency-version: 1.30.0
  dependency-type: indirect
  dependency-group: uv
- dependency-name: mcp
  dependency-version: 2.2.0
  dependency-type: indirect
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-llamaindex/uv.lock      |  8 ++++----
 examples/example-ai-openai-agents/uv.lock   | 18 ++++++++---------
 examples/example-ai-pydantic-ai/uv.lock     | 10 +++++-----
 examples/example-ai-semantic-kernel/uv.lock | 22 +++++++++++----------
 4 files changed, 30 insertions(+), 28 deletions(-)

diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index 0068648e4..aaba29e51 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -1763,7 +1763,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.66.0"
+version = "7.70.2"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2460,11 +2460,11 @@ wheels = [
 
 [[package]]
 name = "tinytag"
-version = "2.2.1"
+version = "2.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/59/8a8cb2331e2602b53e4dc06960f57d1387a2b18e7efd24e5f9cb60ea4925/tinytag-2.2.1.tar.gz", hash = "sha256:e6d06610ebe7cd66fd07be2d3b9495914ab32654a5e47657bb8cd44c2484523c", size = 38214, upload-time = "2026-03-15T18:48:01.11Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/a4/a1d39cc10b43cbbae268127a1c38d689bc6a85cf966f9445bc9f1f5f517a/tinytag-2.3.0.tar.gz", hash = "sha256:84850f8045424b944475b9754bc35c7e09bcae1ab08d1f88d9293aa33af39a27", size = 44379, upload-time = "2026-07-30T23:35:03.407Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/34/d50e338631baaf65ec5396e70085e5de0b52b24b28db1ffbc1c6e82190dc/tinytag-2.2.1-py3-none-any.whl", hash = "sha256:ed8b1e6d25367937e3321e054f4974f9abfde1a3e0a538824c87da377130c2b6", size = 32927, upload-time = "2026-03-15T18:47:59.613Z" },
+    { url = "https://files.pythonhosted.org/packages/90/48/f9a955e0d27376dd0a6bcf7973818b19e5965dd847580aef2f08c6d6f64b/tinytag-2.3.0-py3-none-any.whl", hash = "sha256:231ba5b2fb7a6db478f6dd344ebf20dfdfcd5907f142d475605d516dd7e8b9a8", size = 37155, upload-time = "2026-07-30T23:35:02.003Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-openai-agents/uv.lock b/examples/example-ai-openai-agents/uv.lock
index 63ad72f88..a2ffba110 100644
--- a/examples/example-ai-openai-agents/uv.lock
+++ b/examples/example-ai-openai-agents/uv.lock
@@ -584,7 +584,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.28.1"
+version = "1.30.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -602,9 +602,9 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/93/0142dc84a666daf8ad51a34268f34c12fd6fda4f3810c4be2504eecc8212/mcp-1.30.0.tar.gz", hash = "sha256:445414625fce5c295faa505bb11bacece661ab6f4028d57c935db57820b7a3e4", size = 680511, upload-time = "2026-09-07T14:34:15.845Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
 ]
 
 [[package]]
@@ -848,11 +848,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]
@@ -1070,15 +1070,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "1.6.0"
+version = "1.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/2b/3850dc6bf7ef71b088962eba31dafc6cffd2f96e577ebb0bb316df96da3e/starlette-1.7.0.tar.gz", hash = "sha256:c79f74ea63cff761804fbbfb182f1e0b440c2d07b164d24700c5a1bab5d6ff5d", size = 2736246, upload-time = "2026-09-23T07:30:26.35Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/d6/1ec1b290f9e0fb067899b61e1d37a30c923068bad260b216dbe37a7d2967/starlette-1.7.0-py3-none-any.whl", hash = "sha256:67f8e99895493dd2911a03f11314af6ceebeae4e704bb9f43dfc6a9db151c93e", size = 78980, upload-time = "2026-09-23T07:30:24.567Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index 90f37651d..0a303b6ab 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -4,8 +4,8 @@ requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.14' and sys_platform != 'win32'",
-    "python_full_version < '3.14' and sys_platform == 'win32'",
     "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version < '3.14' and sys_platform == 'win32'",
     "(python_full_version < '3.12' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32')",
 ]
 
@@ -1631,7 +1631,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.29.1"
+version = "1.30.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1649,9 +1649,9 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b5/48/0bb26fdfe7ac16875f534a101ce2405eae192bdef37e7451f2f4507c13ec/mcp-1.29.1.tar.gz", hash = "sha256:1967ba4c315f7a375146209949f45950d18b0efd2f913d7cf3400bc723ee5f04", size = 646823, upload-time = "2026-08-24T18:30:41.161Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/93/0142dc84a666daf8ad51a34268f34c12fd6fda4f3810c4be2504eecc8212/mcp-1.30.0.tar.gz", hash = "sha256:445414625fce5c295faa505bb11bacece661ab6f4028d57c935db57820b7a3e4", size = 680511, upload-time = "2026-09-07T14:34:15.845Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/04/d6b4fb82eefe9e81807aabca1ac98f460ae0883974b83a997aaa20c52545/mcp-1.29.1-py3-none-any.whl", hash = "sha256:b6310eeb59153300c4ab8b9aec4c52f4819a2d6a8e429eb43d908bed7c783648", size = 224653, upload-time = "2026-08-24T18:30:39.573Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
 ]
 
 [[package]]
@@ -2066,7 +2066,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.66.0"
+version = "7.70.2"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
diff --git a/examples/example-ai-semantic-kernel/uv.lock b/examples/example-ai-semantic-kernel/uv.lock
index 7ba0cc72f..956aa7a39 100644
--- a/examples/example-ai-semantic-kernel/uv.lock
+++ b/examples/example-ai-semantic-kernel/uv.lock
@@ -1350,7 +1350,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "2.1.1"
+version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1368,22 +1368,22 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d4/6e/21fb8e5d579dbe21d96ea4d5034200d46d8bdf2261053b5bd041f3c2f612/mcp-2.1.1.tar.gz", hash = "sha256:50b7ba1ebbe117008ea7bdd288234043e69c20b403d6851d19661e6d431a75ef", size = 3984589, upload-time = "2026-08-25T16:14:02.376Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/31/ac54fb0fdd5b37de704486e288bba4fbbb463f24cfcfedbede407b854513/mcp-2.2.0.tar.gz", hash = "sha256:2dc37ecb1974becdcebdbf7561e7c15a07dbbf20ba21ba16c3593b3038b3afbd", size = 4084129, upload-time = "2026-09-07T16:06:23.439Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/af/8644cc5fa26a59afd2df2e98eeb19e72926887fa4b7441aba4ff661140db/mcp-2.1.1-py3-none-any.whl", hash = "sha256:1c6c31c5d6471c58db76af3af8af67f46d11d01f0a59077d0a308cbdb3d3e915", size = 357912, upload-time = "2026-08-25T16:13:59.024Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/ff/8e7eade68b8a28f7da0ed1085544341b51f9c935dbf6b95c76b7edfea6a0/mcp-2.2.0-py3-none-any.whl", hash = "sha256:bde982589473a060ae145e3406e9a5333fe538c97229ba841f5a7f92be004f81", size = 365656, upload-time = "2026-09-07T16:06:19.711Z" },
 ]
 
 [[package]]
 name = "mcp-types"
-version = "2.1.1"
+version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6a/dd/1c4417dc0b722c23a1669032d5f044e41170fe5d4773b488a50fcce98c32/mcp_types-2.1.1.tar.gz", hash = "sha256:77dcbe48fba73cca71a673f2646a5f037a017b7a0a07ac89cec1113028890eda", size = 66674, upload-time = "2026-08-25T16:14:03.861Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/91/762d7755d971aff8a28d75f7961656148edf27875c8026e6385aaab08ae7/mcp_types-2.2.0.tar.gz", hash = "sha256:d3ed53703ddd10d9c6399f29d322bb66f3f67ab41348ac8556ba23e07fedefad", size = 65892, upload-time = "2026-09-07T16:06:25.187Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/d0/242e63c510f4a17381f55b1549a3f94f5687a0595984febd2b6f87a687a0/mcp_types-2.1.1-py3-none-any.whl", hash = "sha256:26f9f7f03f2a5730717a5b98e2ab7eb640ac352d05a00cdc725c311864778295", size = 69656, upload-time = "2026-08-25T16:14:00.667Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/d7/6ffba5d8cd5dd9b8a19478875c50e04945314ba5074e84d749283f27f62d/mcp_types-2.2.0-py3-none-any.whl", hash = "sha256:ea476b73ee86709ab5abc9452385ed36cc05907e582355622e294595c9a04f13", size = 69106, upload-time = "2026-09-07T16:06:21.461Z" },
 ]
 
 [[package]]
@@ -1969,7 +1969,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.70.2"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1993,7 +1993,9 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -2426,11 +2428,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]

From a89acf807c35a780545c1327530c97c8c1b0a008 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 14:00:38 -0700
Subject: [PATCH 041/245] chore(deps-dev): bump claude-agent-sdk from 0.1.50 to
 0.2.121 (#1073)

Bumps [claude-agent-sdk](https://github.com/anthropics/claude-agent-sdk-python) from 0.1.50 to 0.2.121.
- [Release notes](https://github.com/anthropics/claude-agent-sdk-python/releases)
- [Changelog](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/anthropics/claude-agent-sdk-python/compare/v0.1.50...v0.2.121)

---
updated-dependencies:
- dependency-name: claude-agent-sdk
  dependency-version: 0.2.121
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/uv.lock b/uv.lock
index a34a6d808..96913163d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -593,20 +593,21 @@ wheels = [
 
 [[package]]
 name = "claude-agent-sdk"
-version = "0.1.50"
+version = "0.2.121"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "mcp" },
+    { name = "sniffio" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/24/eb/42a7027a02d3827c6e49f97375a00e6da4708f81295d9afa1a0009ce4abd/claude_agent_sdk-0.1.50.tar.gz", hash = "sha256:e15157792857ecb55274a71f08981efcfda2e169bee7894cbdc245d05ac43203", size = 99070, upload-time = "2026-03-20T23:00:58.646Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/9a/7b176b2afef7e4b671bf3723c2a3b09f912ee071e06c15f7f09c46d30ca2/claude_agent_sdk-0.2.121.tar.gz", hash = "sha256:a00f313ebbbf9a7756ec8734c9e9c3c11c53bd56b144dcbd35d4b1bc54fa1d08", size = 297004, upload-time = "2026-07-17T00:38:20.495Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/97/66bc98d5026dbed68b7469a4990de71d8c40d19713e37dafacf32ba3be3b/claude_agent_sdk-0.1.50-py3-none-macosx_11_0_arm64.whl", hash = "sha256:858b1822451209b2c3ad8df27458168d29ac19fd628680853f7707ea017fea73", size = 58223299, upload-time = "2026-03-20T23:01:01.742Z" },
-    { url = "https://files.pythonhosted.org/packages/35/0d/65dda40016faa30a63a950d48b400ad26913e8e333e418651faf04d20673/claude_agent_sdk-0.1.50-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:44e75b9d076bd6030742729f99eb38777b80f052b22338d0a028d8190fc59e52", size = 61019645, upload-time = "2026-03-20T23:01:04.742Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/c0/e5c7c6b9e378553fe24bb5367caede725e274a494b6d126e719971c53b8b/claude_agent_sdk-0.1.50-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:7363d431dc6efd83fa658a045e14fa4357440352b548002bfb9096d8f04d143c", size = 74590847, upload-time = "2026-03-20T23:01:07.899Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/af/658a28cb070e0b59ac98e88411536f6f9b8d81e8ddde9a8340106b0b8b0f/claude_agent_sdk-0.1.50-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:493d8cc43f4166291606749cf47b03e822f03b7f371cc77af697564017ccf579", size = 75231505, upload-time = "2026-03-20T23:01:11.45Z" },
-    { url = "https://files.pythonhosted.org/packages/41/44/ff1f2c137406392fa0a69e3c3ff37150267da664decddb6dee83b80ba162/claude_agent_sdk-0.1.50-py3-none-win_amd64.whl", hash = "sha256:2e44caf3e5bce56e26a18158acf3e1c2c2784cf8fa15e425afe92816c987eb1a", size = 75846174, upload-time = "2026-03-20T23:01:15.277Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/3b/16325094d09ca5fbfb92cab11c6f01ff072f4077879ecfcf0004464da3c5/claude_agent_sdk-0.2.121-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6d4707c4626434e75c35f350e66312d8447221c97208f1775d4b4c6542b8d2f2", size = 71735241, upload-time = "2026-07-17T00:38:23.74Z" },
+    { url = "https://files.pythonhosted.org/packages/53/d8/cfcd5ea965e0e54cdab58d74d01580489eb5cc02c331e1d2577083b12c06/claude_agent_sdk-0.2.121-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:9c58d83ae9feacc3f06038d86c403e3785a166ef27ae5ae52842864c9a72b90f", size = 76705265, upload-time = "2026-07-17T00:38:27.559Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/6d/304282a3e73fa528621508fc205f608c48ca679b176a7ba7003e7e4bcf25/claude_agent_sdk-0.2.121-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:e5b788269f731e73b89785415010fa750ddcf0f35eb9bb4a20bc64e9f52356b4", size = 81636213, upload-time = "2026-07-17T00:38:31.038Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a8/b08d07d090bf07bd84a4243f98813b1c2bea6dc310aa58a7581f216ee89f/claude_agent_sdk-0.2.121-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:65ccbb1bbeed53d8bc60e87a1d46b903b8ba5636a6b300eaa0d284035f844ece", size = 82695285, upload-time = "2026-07-17T00:38:35.198Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/69/af814cc15b00ce97132714052a5b3374151d2697fb559600c6187853f327/claude_agent_sdk-0.2.121-py3-none-win_amd64.whl", hash = "sha256:aa34c094aa9278823d64292db0a624bf1dadb800bcc769a96742393fcf01fb9f", size = 82562260, upload-time = "2026-07-17T00:38:38.674Z" },
 ]
 
 [[package]]

From facd617491a74d8c3c751f0a628661b3817b250d Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Mon, 19 Oct 2026 12:08:09 +0300
Subject: [PATCH 042/245] feat(mcp): stop sending standalone $identify events
 (#1067)

* feat(mcp): stop sending standalone $identify events

The identify callback still sets distinct_id, $set and $groups on every
event. The standalone event carried no $anon_distinct_id, so ingestion
merged no person, and stateless servers sent one per tool call.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(mcp): assert no $identify over the wire and refresh docs

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .sampo/changesets/quiet-mcp-identify.md   |  5 ++
 examples/mcp_analytics_demo.py            |  2 +-
 posthog/mcp/_event_types.py               |  1 -
 posthog/mcp/_instrumentation.py           | 10 ++-
 posthog/mcp/_internal.py                  | 85 +++--------------------
 posthog/mcp/_posthog_events.py            |  1 -
 posthog/mcp/constants.py                  |  1 +
 posthog/test/mcp/test_fastmcp.py          |  3 +-
 posthog/test/mcp/test_lowlevel.py         | 16 ++---
 posthog/test/mcp/test_pipeline.py         |  5 --
 posthog/test/mcp/test_units.py            |  8 ---
 posthog/test/mcp/test_v2_mcpserver.py     | 16 +----
 posthog/test/mcp/test_v2_wire_dual_era.py | 45 +++++++++++-
 13 files changed, 73 insertions(+), 125 deletions(-)
 create mode 100644 .sampo/changesets/quiet-mcp-identify.md

diff --git a/.sampo/changesets/quiet-mcp-identify.md b/.sampo/changesets/quiet-mcp-identify.md
new file mode 100644
index 000000000..8a8fd3b16
--- /dev/null
+++ b/.sampo/changesets/quiet-mcp-identify.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+MCP analytics no longer sends standalone `$identify` events, so insights, funnels, or cohorts built on MCP `$identify` stop receiving new data. The `identify` callback still sets `distinct_id`, `$set` and `$groups` on every event.
diff --git a/examples/mcp_analytics_demo.py b/examples/mcp_analytics_demo.py
index 23f30b6cc..e2d274608 100644
--- a/examples/mcp_analytics_demo.py
+++ b/examples/mcp_analytics_demo.py
@@ -72,7 +72,7 @@ async def main() -> None:
     list_handler = server._mcp_server.request_handlers[mcp_types.ListToolsRequest]
     await list_handler(mcp_types.ListToolsRequest(method="tools/list"))
 
-    # tool calls -> $mcp_initialize (lazy, once), $identify, $mcp_tool_call x3, $exception
+    # tool calls -> $mcp_initialize (lazy, once), $mcp_tool_call x3, $exception
     await server._tool_manager.call_tool(
         "add",
         {"a": 2, "b": 3, "context": "adding two numbers to demo the python mcp sdk"},
diff --git a/posthog/mcp/_event_types.py b/posthog/mcp/_event_types.py
index 75778dcd8..7392f90a9 100644
--- a/posthog/mcp/_event_types.py
+++ b/posthog/mcp/_event_types.py
@@ -13,7 +13,6 @@
 class MCPAnalyticsEventType:
     """Protocol-shaped event types observed by the SDK (internal dispatch keys)."""
 
-    IDENTIFY = "posthog:identify"
     CUSTOM = "posthog:custom"
     MCP_FEEDBACK = "mcp:feedback"
     MCP_MISSING_CAPABILITY = "mcp:missing_capability"
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index 167969069..03b66392c 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -377,9 +377,9 @@ async def prepare_request(
     the session id to stamp on the event for this request.
 
     ``conversation_id`` is the agent's handle for this request, and when present
-    it anchors the session (ADR-0004) so every event of the request — identify,
-    initialize, and the call itself — lands in the conversation's session rather
-    than this instance's.
+    it anchors the session (ADR-0004) so every event of the request — initialize
+    and the call itself — lands in the conversation's session rather than this
+    instance's.
 
     Callers pass it only for a handle the agent **echoed**. A freshly minted one
     is unproven: this runs before the call, so delivery cannot be known yet, and
@@ -412,9 +412,7 @@ async def prepare_request(
         and not _is_sse_request(extra)
     ):
         _warn_stateless_session_not_wired(data)
-    identify_event = await handle_identify(data, session_id, request, extra)
-    if identify_event:
-        fire_and_forget(capture_event(data, identify_event), data)
+    await handle_identify(data, session_id, request, extra)
     await _maybe_emit_initialize(
         data, session_id, client_name, client_version, extra, protocol_version
     )
diff --git a/posthog/mcp/_internal.py b/posthog/mcp/_internal.py
index 12bc83d28..8da3cd8d0 100644
--- a/posthog/mcp/_internal.py
+++ b/posthog/mcp/_internal.py
@@ -12,7 +12,6 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import weakref
 from collections import OrderedDict
 from dataclasses import dataclass, field
@@ -139,25 +138,6 @@ def set_server_tracking_data(server: Any, data: MCPAnalyticsData) -> None:
     _server_tracking[server] = data
 
 
-def are_identities_equal(a: UserIdentity, b: UserIdentity) -> bool:
-    if a.distinct_id != b.distinct_id:
-        return False
-    if json.dumps(a.groups or {}, sort_keys=True) != json.dumps(
-        b.groups or {}, sort_keys=True
-    ):
-        return False
-    a_props = a.properties or {}
-    b_props = b.properties or {}
-    if set(a_props.keys()) != set(b_props.keys()):
-        return False
-    for key in a_props:
-        if json.dumps(a_props[key], sort_keys=True, default=str) != json.dumps(
-            b_props[key], sort_keys=True, default=str
-        ):
-            return False
-    return True
-
-
 def merge_identities(
     previous: Optional[UserIdentity], nxt: UserIdentity
 ) -> UserIdentity:
@@ -176,35 +156,18 @@ async def _maybe_await(value: Any) -> Any:
     return value
 
 
-def _captured_extra(extra: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-    """Project ``extra`` down to JSON-safe scalars before it is captured.
-
-    Callbacks (``identify``, ``event_properties``, ``intent_fallback``) receive
-    the full dict — on MCP SDK v2 that includes the raw request ``ctx`` so hosts
-    can read headers. Captured event parameters must not: the sanitizer leaves
-    opaque objects untouched and truncation stringifies them, which would ship
-    whatever the object's repr carries (headers, auth material, transport state)
-    to PostHog without key-based redaction."""
-    if extra is None:
-        return None
-    return {
-        key: value
-        for key, value in extra.items()
-        if value is None or isinstance(value, (str, int, float, bool))
-    }
-
-
 async def handle_identify(
     data: MCPAnalyticsData,
     session_id: str,
     request: Dict[str, Any],
     extra: Optional[Dict[str, Any]] = None,
-) -> Optional[Dict[str, Any]]:
-    """Resolve the optional ``identify`` callback, dedupe against the identity
-    cache, and return an ``$identify`` event to emit only when the identity has
-    materially changed (otherwise ``None``)."""
+) -> None:
+    """Resolve the optional ``identify`` callback and merge the result into the
+    session's cached identity. Every event of the session then carries it as
+    ``distinct_id``/``$set``, so no standalone ``$identify`` is sent: without an
+    ``$anon_distinct_id`` it would merge no person in ingestion."""
     if not data.options.identify:
-        return None
+        return
 
     try:
         identify = data.options.identify
@@ -217,29 +180,16 @@ async def handle_identify(
             log(
                 f"Warning: Supplied identify function returned null for session {session_id}"
             )
-            return None
+            return
 
         previous = data.identified_sessions.get(session_id)
-        merged = merge_identities(previous, identity_result)
-        has_changed = not (previous and are_identities_equal(previous, merged))
-        data.identified_sessions.set(session_id, merged)
-
-        if has_changed:
-            from ._event_types import MCPAnalyticsEventType
-
-            log(f"Identified session {session_id}")
-            return {
-                "session_id": session_id,
-                "resource_name": _get_request_resource_name(request),
-                "event_type": MCPAnalyticsEventType.IDENTIFY,
-                "parameters": {"request": request, "extra": _captured_extra(extra)},
-                "timestamp": datetime.now(timezone.utc),
-            }
+        data.identified_sessions.set(
+            session_id, merge_identities(previous, identity_result)
+        )
     except Exception as error:  # noqa: BLE001
         log(
             f"Error: identify function threw while identifying session {session_id} - {error}"
         )
-    return None
 
 
 async def resolve_event_properties(
@@ -254,18 +204,3 @@ async def resolve_event_properties(
     except Exception as e:  # noqa: BLE001
         log(f"event_properties callback error: {e}")
         return None
-
-
-def _get_request_resource_name(request: Any) -> str:
-    """The thing the request acts on: a tool/prompt ``name``, or the ``uri`` of a
-    resource read — which is the only name a ``resources/read`` request carries."""
-    if not isinstance(request, dict):
-        return "Unknown"
-    params = request.get("params")
-    if not isinstance(params, dict):
-        return "Unknown"
-    for key in ("name", "uri"):
-        value = params.get(key)
-        if isinstance(value, str):
-            return value
-    return "Unknown"
diff --git a/posthog/mcp/_posthog_events.py b/posthog/mcp/_posthog_events.py
index 7113bd2cb..51fc5ff75 100644
--- a/posthog/mcp/_posthog_events.py
+++ b/posthog/mcp/_posthog_events.py
@@ -20,7 +20,6 @@
 
 _BUILT_IN_EVENT_NAME_BY_TYPE = {
     MCPAnalyticsEventType.CUSTOM: PostHogMCPAnalyticsEvent.CUSTOM,
-    MCPAnalyticsEventType.IDENTIFY: PostHogMCPAnalyticsEvent.IDENTIFY,
     MCPAnalyticsEventType.MCP_FEEDBACK: PostHogMCPAnalyticsEvent.FEEDBACK,
     MCPAnalyticsEventType.MCP_MISSING_CAPABILITY: PostHogMCPAnalyticsEvent.MISSING_CAPABILITY,
     MCPAnalyticsEventType.MCP_INITIALIZE: PostHogMCPAnalyticsEvent.INITIALIZE,
diff --git a/posthog/mcp/constants.py b/posthog/mcp/constants.py
index ab5dd363e..de359e693 100644
--- a/posthog/mcp/constants.py
+++ b/posthog/mcp/constants.py
@@ -53,6 +53,7 @@ class PostHogMCPAnalyticsEvent:
     CUSTOM = "$mcp_custom"
     EXCEPTION = "$exception"
     FEEDBACK = "$mcp_feedback"
+    # Deprecated: the SDK no longer sends `$identify`.
     IDENTIFY = "$identify"
     INITIALIZE = "$mcp_initialize"
     MISSING_CAPABILITY = "$mcp_missing_capability"
diff --git a/posthog/test/mcp/test_fastmcp.py b/posthog/test/mcp/test_fastmcp.py
index df725009e..53cdfea34 100644
--- a/posthog/test/mcp/test_fastmcp.py
+++ b/posthog/test/mcp/test_fastmcp.py
@@ -256,8 +256,7 @@ async def test_identify_sets_distinct_id_and_groups():
     assert calls[0]["distinct_id"] == "user_42"
     assert calls[0]["properties"]["$groups"] == {"organization": "org_7"}
     assert "$process_person_profile" not in calls[0]["properties"]
-    # an $identify event was emitted
-    assert _events(client, "$identify")
+    assert not _events(client, "$identify")
 
 
 async def test_instrument_is_idempotent():
diff --git a/posthog/test/mcp/test_lowlevel.py b/posthog/test/mcp/test_lowlevel.py
index b51a5a10a..62dbd1ed0 100644
--- a/posthog/test/mcp/test_lowlevel.py
+++ b/posthog/test/mcp/test_lowlevel.py
@@ -291,7 +291,7 @@ async def test_failed_resource_listing_is_captured() -> None:
     assert "listing unavailable" in json.dumps(exceptions[0]["properties"])
 
 
-async def test_identify_on_a_resource_read_is_named_by_the_uri() -> None:
+async def test_identify_attributes_a_resource_read_without_an_identify_event() -> None:
     server = make_server()
     client = FakeClient()
     instrument(
@@ -304,21 +304,13 @@ async def test_identify_on_a_resource_read_is_named_by_the_uri() -> None:
 
     await server.request_handlers[mcp_types.ReadResourceRequest](
         mcp_types.ReadResourceRequest(
-            params=mcp_types.ReadResourceRequestParams(
-                uri="https://fakeuser:fakepass@example.com/guide"
-            )
+            params=mcp_types.ReadResourceRequestParams(uri="https://example.com/guide")
         )
     )
     await _flush()
 
-    identified = _events(client, "$identify")
-    assert len(identified) == 1
-    # A resources/read request carries no `name`, so the uri is the only thing
-    # that can name it — sanitized like any other captured URL.
-    assert (
-        identified[0]["properties"]["$mcp_resource_name"]
-        == "https://%5Bredacted%5D@example.com/guide"
-    )
+    assert not _events(client, "$identify")
+    assert _events(client, "$mcp_resource_read")[0]["distinct_id"] == "user_42"
 
 
 async def test_tool_call_success_captures_intent():
diff --git a/posthog/test/mcp/test_pipeline.py b/posthog/test/mcp/test_pipeline.py
index c3e39f2cf..6a4dda12f 100644
--- a/posthog/test/mcp/test_pipeline.py
+++ b/posthog/test/mcp/test_pipeline.py
@@ -703,11 +703,6 @@ def test_redact_pii_is_not_quadratic_on_pathological_input():
             "Get_Organization_Memberships",
             "Get_Organization_Memberships",
         ),
-        (
-            MCPAnalyticsEventType.IDENTIFY,
-            "https://fakeuser:fakepass@example.com/doc",
-            "https://%5Bredacted%5D@example.com/doc",
-        ),
         (
             MCPAnalyticsEventType.MCP_RESOURCES_READ,
             "https://example.com/guide?token=fakesecret",
diff --git a/posthog/test/mcp/test_units.py b/posthog/test/mcp/test_units.py
index c07c85ab6..49316a1fb 100644
--- a/posthog/test/mcp/test_units.py
+++ b/posthog/test/mcp/test_units.py
@@ -28,7 +28,6 @@
 from posthog.mcp._internal import (
     IdentityCache,
     MCPAnalyticsData,
-    are_identities_equal,
     merge_identities,
 )
 from posthog.mcp.session import (
@@ -385,13 +384,6 @@ async def test_resolve_session_id_rolls_over_after_inactivity():
 # --- identity cache / merge --------------------------------------------------
 
 
-def test_are_identities_equal():
-    a = UserIdentity(distinct_id="u1", properties={"plan": "pro"}, groups={"org": "o1"})
-    b = UserIdentity(distinct_id="u1", properties={"plan": "pro"}, groups={"org": "o1"})
-    assert are_identities_equal(a, b)
-    assert not are_identities_equal(a, UserIdentity(distinct_id="u2"))
-
-
 def test_merge_identities_merges_properties_and_keeps_distinct_id():
     merged = merge_identities(
         UserIdentity(distinct_id="u1", properties={"a": 1}),
diff --git a/posthog/test/mcp/test_v2_mcpserver.py b/posthog/test/mcp/test_v2_mcpserver.py
index c17e6de15..cdc991ac1 100644
--- a/posthog/test/mcp/test_v2_mcpserver.py
+++ b/posthog/test/mcp/test_v2_mcpserver.py
@@ -235,14 +235,12 @@ async def test_identify_sets_distinct_id_and_groups():
     calls = _events(client, "$mcp_tool_call")
     assert calls[0]["distinct_id"] == "user_42"
     assert calls[0]["properties"]["$groups"] == {"organization": "org_7"}
-    assert _events(client, "$identify")
+    assert not _events(client, "$identify")
 
 
-async def test_identify_callback_sees_ctx_but_capture_does_not():
+async def test_identify_callback_sees_ctx():
     """The v2 adapters hand the raw request ``ctx`` to callbacks via ``extra`` so
-    hosts can read headers — but the captured $identify parameters must carry
-    only a scalar projection, or the stringified context (headers, transport
-    state) would ship to PostHog without key-based redaction."""
+    hosts can read headers."""
     server = make_server()
     client = FakeClient()
     seen = {}
@@ -258,16 +256,8 @@ def identify(request, extra):
     )
     await _flush()
 
-    # the callback got the live context object...
     assert seen["extra"]["ctx"] is not None
 
-    # ...but the captured event only carries JSON-safe scalars
-    identify_events = _events(client, "$identify")
-    assert identify_events
-    captured_extra = identify_events[0]["properties"]["$mcp_parameters"]["extra"]
-    assert "ctx" not in captured_extra
-    assert set(captured_extra) <= {"session_id"}
-
 
 async def test_structured_output_tool_gets_the_conversation_handle():
     """A tool that declares an output schema is served to clients that read
diff --git a/posthog/test/mcp/test_v2_wire_dual_era.py b/posthog/test/mcp/test_v2_wire_dual_era.py
index 0e89b69b1..58fbf4e9a 100644
--- a/posthog/test/mcp/test_v2_wire_dual_era.py
+++ b/posthog/test/mcp/test_v2_wire_dual_era.py
@@ -19,6 +19,7 @@
 from contextlib import asynccontextmanager
 
 import httpx
+import pytest
 from mcp.server.mcpserver import MCPServer
 
 from posthog.mcp import (
@@ -26,7 +27,7 @@
     derive_session_id_from_conversation,
     instrument,
 )
-from posthog.mcp.types import MCPAnalyticsOptions
+from posthog.mcp.types import MCPAnalyticsOptions, UserIdentity
 from posthog.test.mcp._helpers import (
     FakeClient,
     events_named as _events,
@@ -241,6 +242,48 @@ async def test_modern_result_shape_survives_instrumentation():
     assert result.get("structuredContent") == bare_result.get("structuredContent")
 
 
+@pytest.mark.parametrize("era", ["legacy", "modern"])
+async def test_identify_sends_no_identify_event_across_instances(era):
+    """Each call lands on a fresh instance with no session token, so every
+    identity is first-seen. Attribution must still come from the callback."""
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False,
+        identify=lambda request, extra: UserIdentity(
+            distinct_id="user_42", properties={"plan": "paid"}
+        ),
+    )
+
+    for request_id in (1, 2):
+        server = make_server()
+        instrument(server, client, options)
+        async with wire(server) as http:
+            if era == "modern":
+                response = await modern_call(
+                    http, "add", {"a": 1, "b": 2, "context": "pod"}, request_id
+                )
+            else:
+                call = rpc(
+                    "tools/call",
+                    {"name": "add", "arguments": {"a": 1, "b": 2, "context": "pod"}},
+                    request_id,
+                )
+                headers = {
+                    **legacy_headers(),
+                    "mcp-protocol-version": LEGACY_PROTOCOL_VERSION,
+                }
+                response = await http.post("/mcp", json=call, headers=headers)
+        assert response.status_code == 200
+    await _flush()
+
+    assert not _events(client, "$identify")
+    calls = _events(client, "$mcp_tool_call")
+    assert len(calls) == 2
+    for call in calls:
+        assert call["distinct_id"] == "user_42"
+        assert call["properties"]["$set"] == {"plan": "paid"}
+
+
 # --- legacy era (2025-11-25) on the v2 SDK -------------------------------------
 
 

From 876b955942cf86579dfda7032ec03a42de06769f Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 14:36:26 +0000
Subject: [PATCH 043/245] chore: Release v7.72.0 [skip ci]

---
 .sampo/changesets/quiet-mcp-identify.md | 5 -----
 openfeature-provider/CHANGELOG.md       | 6 ++++++
 openfeature-provider/pyproject.toml     | 2 +-
 posthog/CHANGELOG.md                    | 6 ++++++
 posthog/version.py                      | 2 +-
 pyproject.toml                          | 2 +-
 uv.lock                                 | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/quiet-mcp-identify.md

diff --git a/.sampo/changesets/quiet-mcp-identify.md b/.sampo/changesets/quiet-mcp-identify.md
deleted file mode 100644
index 8a8fd3b16..000000000
--- a/.sampo/changesets/quiet-mcp-identify.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-MCP analytics no longer sends standalone `$identify` events, so insights, funnels, or cohorts built on MCP `$identify` stop receiving new data. The `identify` callback still sets `distinct_id`, `$set` and `$groups` on every event.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 0a671dafb..bc04fd642 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.108 — 2026-10-19
+
+### Patch changes
+
+- Updated dependencies: posthog@7.72.0
+
 ## 0.1.107 — 2026-10-16
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 6bcc7ae10..3b050c912 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.107"
+version = "0.1.108"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 1baddc69b..d86fb82b4 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.72.0 — 2026-10-19
+
+### Minor changes
+
+- [facd617](https://github.com/posthog/posthog-python/commit/facd617491a74d8c3c751f0a628661b3817b250d) MCP analytics no longer sends standalone `$identify` events, so insights, funnels, or cohorts built on MCP `$identify` stop receiving new data. The `identify` callback still sets `distinct_id`, `$set` and `$groups` on every event. — Thanks @gesh!
+
 ## 7.71.0 — 2026-10-16
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 08106028b..36a0dbd29 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.71.0"
+VERSION = "7.72.0"
diff --git a/pyproject.toml b/pyproject.toml
index 44e84c33a..2314476ec 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.71.0"
+version = "7.72.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 96913163d..f16efb7de 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2500,7 +2500,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.107"
+version = "0.1.108"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2830,7 +2830,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.71.0"
+version = "7.72.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From b8327de20f3ed1ba59863c1cbb7e086655cdce12 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 14:36:31 +0000
Subject: [PATCH 044/245] Update generated references

---
 .../posthog-python-references-7.72.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.72.0.json

diff --git a/references/posthog-python-references-7.72.0.json b/references/posthog-python-references-7.72.0.json
new file mode 100644
index 000000000..05421adfc
--- /dev/null
+++ b/references/posthog-python-references-7.72.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.72.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 342930ffc..05421adfc 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.71.0",
+    "version": "7.72.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 3822271b1f45d31e24e717b61ad5c2db1224503d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 13:13:16 -0400
Subject: [PATCH 045/245] chore(deps): bump the github-actions group with 6
 updates (#1083)

Bumps the github-actions group with 6 updates:

| Package | From | To |
| --- | --- | --- |
| [astral-sh/setup-uv](https://github.com/astral-sh/setup-uv) | `10.2.0` | `10.3.0` |
| [github/codeql-action/init](https://github.com/github/codeql-action) | `4.38.2` | `4.38.3` |
| [github/codeql-action/analyze](https://github.com/github/codeql-action) | `4.38.2` | `4.38.3` |
| [actions/create-github-app-token](https://github.com/actions/create-github-app-token) | `3.2.0` | `3.3.0` |
| [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain) | `e2a55d2ffb04f378e9626c28d38b36d230d1e12f` | `683b588c487a69d01f6c6ddf40f036ff682cc2c8` |
| [PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml](https://github.com/posthog/posthog-sdk-test-harness) | `1.13.1` | `1.15.0` |


Updates `astral-sh/setup-uv` from 10.2.0 to 10.3.0
- [Release notes](https://github.com/astral-sh/setup-uv/releases)
- [Commits](https://github.com/astral-sh/setup-uv/compare/c18668ad3cf93ea998bef934396af7bb5c839dc7...1c37ad07a6a961277cf70c0d37d6f313000f5884)

Updates `github/codeql-action/init` from 4.38.2 to 4.38.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...24c54180a607b1449ed407dd24f251e4e9147c8d)

Updates `github/codeql-action/analyze` from 4.38.2 to 4.38.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2...24c54180a607b1449ed407dd24f251e4e9147c8d)

Updates `actions/create-github-app-token` from 3.2.0 to 3.3.0
- [Release notes](https://github.com/actions/create-github-app-token/releases)
- [Changelog](https://github.com/actions/create-github-app-token/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/create-github-app-token/compare/bcd2ba49218906704ab6c1aa796996da409d3eb1...64ab729a6294000f5aa4a4bc0b73d1f32bc45510)

Updates `dtolnay/rust-toolchain` from e2a55d2ffb04f378e9626c28d38b36d230d1e12f to 683b588c487a69d01f6c6ddf40f036ff682cc2c8
- [Release notes](https://github.com/dtolnay/rust-toolchain/releases)
- [Commits](https://github.com/dtolnay/rust-toolchain/compare/e2a55d2ffb04f378e9626c28d38b36d230d1e12f...683b588c487a69d01f6c6ddf40f036ff682cc2c8)

Updates `PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml` from 1.13.1 to 1.15.0
- [Release notes](https://github.com/posthog/posthog-sdk-test-harness/releases)
- [Changelog](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/CHANGELOG.md)
- [Commits](https://github.com/posthog/posthog-sdk-test-harness/compare/e32f08bd30fab57ce543da5808a668d0fda697b0...64ffa6ab19166541880c077d349abe18a7e42395)

---
updated-dependencies:
- dependency-name: astral-sh/setup-uv
  dependency-version: 10.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.38.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.38.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: actions/create-github-app-token
  dependency-version: 3.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: dtolnay/rust-toolchain
  dependency-version: 683b588c487a69d01f6c6ddf40f036ff682cc2c8
  dependency-type: direct:production
  dependency-group: github-actions
- dependency-name: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml
  dependency-version: 1.15.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml              | 12 ++++++------
 .github/workflows/codeql.yml          |  4 ++--
 .github/workflows/posthog-upgrade.yml |  2 +-
 .github/workflows/release.yml         | 12 ++++++------
 .github/workflows/sdk-compliance.yml  |  4 ++--
 5 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 41336cc71..f92d5194d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -109,7 +109,7 @@ jobs:
                   python-version: 3.11.11
 
             - name: Install uv
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
@@ -137,7 +137,7 @@ jobs:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
@@ -176,7 +176,7 @@ jobs:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
@@ -242,7 +242,7 @@ jobs:
 
             - name: Install uv
               if: steps.changes.outputs.changed == 'true'
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
@@ -323,7 +323,7 @@ jobs:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
@@ -378,7 +378,7 @@ jobs:
                   python-version: 3.12
 
             - name: Install uv
-              uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
                   version: "0.11.32"
                   enable-cache: true
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 262d83807..fcaca264b 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -40,6 +40,6 @@ jobs:
           trap-caching: false
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           category: '/language:${{matrix.language}}'
diff --git a/.github/workflows/posthog-upgrade.yml b/.github/workflows/posthog-upgrade.yml
index 19a04aa24..585f2958b 100644
--- a/.github/workflows/posthog-upgrade.yml
+++ b/.github/workflows/posthog-upgrade.yml
@@ -42,7 +42,7 @@ jobs:
           token: ${{ steps.upgrader.outputs.token }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           version: "0.12.21"
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 6987f2f53..2de109583 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -83,7 +83,7 @@ jobs:
 
       - name: Get GitHub App token
         id: releaser
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
+        uses: actions/create-github-app-token@64ab729a6294000f5aa4a4bc0b73d1f32bc45510 # v3.3.0
         with:
           client-id: ${{ secrets.GH_APP_POSTHOG_PYTHON_RELEASER_APP_ID }}
           private-key: ${{ secrets.GH_APP_POSTHOG_PYTHON_RELEASER_PRIVATE_KEY }}
@@ -101,13 +101,13 @@ jobs:
           python-version: 3.11.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           version: "0.11.32"
           enable-cache: true
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@e2a55d2ffb04f378e9626c28d38b36d230d1e12f
+        uses: dtolnay/rust-toolchain@683b588c487a69d01f6c6ddf40f036ff682cc2c8
         with:
           toolchain: 1.91.1
           components: cargo
@@ -306,7 +306,7 @@ jobs:
           python-version: 3.11.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           version: "0.11.32"
           enable-cache: true
@@ -473,13 +473,13 @@ jobs:
           python-version: 3.11.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           version: "0.11.32"
           enable-cache: true
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@e2a55d2ffb04f378e9626c28d38b36d230d1e12f
+        uses: dtolnay/rust-toolchain@683b588c487a69d01f6c6ddf40f036ff682cc2c8
         with:
           toolchain: 1.91.1
           components: cargo
diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index ad0e0fa71..0e4bfbe77 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -29,7 +29,7 @@ jobs:
 
   compliance:
     name: PostHog SDK compliance tests (capture v0)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@e32f08bd30fab57ce543da5808a668d0fda697b0 # 1.13.1
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@64ffa6ab19166541880c077d349abe18a7e42395 # 1.15.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
@@ -39,7 +39,7 @@ jobs:
 
   compliance-v1:
     name: PostHog SDK compliance tests (capture v1)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@e32f08bd30fab57ce543da5808a668d0fda697b0 # 1.13.1
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@64ffa6ab19166541880c077d349abe18a7e42395 # 1.15.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."

From 9b70476eeeea0f653212bf3f7fe7abba8508b329 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 13:13:22 -0400
Subject: [PATCH 046/245] chore(deps): bump the ai-providers group with 6
 updates (#1082)

Bumps the ai-providers group with 6 updates:

| Package | From | To |
| --- | --- | --- |
| [langchain](https://github.com/langchain-ai/langchain) | `1.4.3` | `1.4.4` |
| [anthropic](https://github.com/anthropics/anthropic-sdk-python) | `1.11.0` | `1.13.0` |
| [langgraph](https://github.com/langchain-ai/langgraph) | `1.2.13` | `1.2.14` |
| [langchain-core](https://github.com/langchain-ai/langchain) | `1.6.6` | `1.6.9` |
| [langchain-openai](https://github.com/langchain-ai/langchain) | `1.6.7` | `1.7.0` |
| [google-genai](https://github.com/googleapis/python-genai) | `2.28.0` | `2.29.0` |


Updates `langchain` from 1.4.3 to 1.4.4
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain==1.4.3...langchain==1.4.4)

Updates `anthropic` from 1.11.0 to 1.13.0
- [Release notes](https://github.com/anthropics/anthropic-sdk-python/releases)
- [Changelog](https://github.com/anthropics/anthropic-sdk-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/anthropics/anthropic-sdk-python/compare/v1.11.0...v1.13.0)

Updates `langgraph` from 1.2.13 to 1.2.14
- [Release notes](https://github.com/langchain-ai/langgraph/releases)
- [Commits](https://github.com/langchain-ai/langgraph/compare/1.2.13...1.2.14)

Updates `langchain-core` from 1.6.6 to 1.6.9
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-core==1.6.6...langchain-core==1.6.9)

Updates `langchain-openai` from 1.6.7 to 1.7.0
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-openai==1.6.7...langchain-openai==1.7.0)

Updates `google-genai` from 2.28.0 to 2.29.0
- [Release notes](https://github.com/googleapis/python-genai/releases)
- [Changelog](https://github.com/googleapis/python-genai/blob/main/CHANGELOG.md)
- [Commits](https://github.com/googleapis/python-genai/compare/v2.28.0...v2.29.0)

---
updated-dependencies:
- dependency-name: langchain
  dependency-version: 1.4.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: anthropic
  dependency-version: 1.13.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
- dependency-name: langgraph
  dependency-version: 1.2.14
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-core
  dependency-version: 1.6.9
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-openai
  dependency-version: 1.7.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
- dependency-name: google-genai
  dependency-version: 2.29.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/uv.lock b/uv.lock
index f16efb7de..54d071319 100644
--- a/uv.lock
+++ b/uv.lock
@@ -226,7 +226,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "1.11.0"
+version = "1.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -237,9 +237,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/12/9a6ffa397b172adb040008d934a1dfd85d0e4cefc77489416db294ffc880/anthropic-1.11.0.tar.gz", hash = "sha256:3906fabac7ad7b5b46c6186040398fc7826885c77ce34e4dd7849de16fc8d0f8", size = 1390390, upload-time = "2026-09-30T22:58:21.098Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/ed/e76e50601b7c476bcb9a2a7a4c4dab6f1a9b2c03e3922de8b3ec599ccbc5/anthropic-1.13.0.tar.gz", hash = "sha256:ad11d9bb9adafdfea26113943bcde9973e2a439ebeeda6c89ff3e3d85bb2f5c1", size = 1567362, upload-time = "2026-10-09T15:29:08.803Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ab/6f/20edcd2956cac68042b1bcdd13ab3311447519f86b26929ff268dc74c650/anthropic-1.11.0-py3-none-any.whl", hash = "sha256:52f97b2c485cca7ac66058374f5073a3febb7e6849b16989c145d602a3efee21", size = 1681654, upload-time = "2026-09-30T22:58:22.925Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/9a/a835340c91bc9a233bd54c05fc438fe07cbef71ca667f24f3892a268ae20/anthropic-1.13.0-py3-none-any.whl", hash = "sha256:157bd74dbf6a595cf9e5fcac557c791fd297924dc48261f57470c2ed6f4e6671", size = 1958595, upload-time = "2026-10-09T15:29:10.689Z" },
 ]
 
 [[package]]
@@ -1147,7 +1147,7 @@ requests = [
 
 [[package]]
 name = "google-genai"
-version = "2.28.0"
+version = "2.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1161,9 +1161,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/59/16/4af15d65cb72ebc21a99c5e64f09072e97334c05a48d4cede19c347e6ad2/google_genai-2.28.0.tar.gz", hash = "sha256:970cb2eaf1951949851c3e0a5b70265cfea8a408fb7361c7c980a84d90672bf2", size = 707359, upload-time = "2026-10-02T17:58:14.454Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/2b/977616ef350e51d3d263eb43be23a91be793544cd937b51c0fac313be233/google_genai-2.29.0.tar.gz", hash = "sha256:124d3eef9ff6b9e4ea548f95ff5b7721683e7990c0a936b006d9e2ab61ea897d", size = 706902, upload-time = "2026-10-07T22:22:57.153Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ad/4b/47278c34757293ba8d9156090d38e1c45fac9a47c50176acff7f77ae9a66/google_genai-2.28.0-py3-none-any.whl", hash = "sha256:cdee15e2fbfea08ea61bce6e5bfbb3301db4bd13a52dccfa8c8d1167e37ca1cc", size = 1168554, upload-time = "2026-10-02T17:58:12.585Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/27/a3dede4a1deb21f7fde6a171daa039bf0ea149a5e7826a785e8f109a6e13/google_genai-2.29.0-py3-none-any.whl", hash = "sha256:7adda55cb6746fb46d38ad3202c3372840b96eede964b5fb3df1469cd4998570", size = 1167603, upload-time = "2026-10-07T22:22:55.215Z" },
 ]
 
 [[package]]
@@ -1641,16 +1641,16 @@ wheels = [
 
 [[package]]
 name = "langchain"
-version = "1.4.3"
+version = "1.4.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "langgraph" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a2/aa/0fcaf5d7dbebcf7d0eb74293dca5aee6f0558242731f4dee4a800cc2431d/langchain-1.4.3.tar.gz", hash = "sha256:aed5c1a7cd581f70ddc076b75fdbcbae8031b8373983f86efd287aa70798abc2", size = 738607, upload-time = "2026-09-28T20:17:24.38Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/a4/a3ceefc3ec734912ca3a21dd79a5e4a98af73015a87e64d284a92cd5572c/langchain-1.4.4.tar.gz", hash = "sha256:baac6e13c08460e1decd0e60061b9a87c07135f1c977424040b0b57ff7bc7887", size = 742902, upload-time = "2026-10-08T22:14:10.86Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/03/8cc027f9d297473de94f134546dae2bfca255161ebbda988522fc509e1d5/langchain-1.4.3-py3-none-any.whl", hash = "sha256:0334066939dd1c7551889727ed2d09a72dea7a6aed2193ffb61817fb658d8921", size = 164708, upload-time = "2026-09-28T20:17:22.978Z" },
+    { url = "https://files.pythonhosted.org/packages/02/36/c348f812eb37a137de2c80140ed1324ab11b75fa5a845e3f1035bacaac4a/langchain-1.4.4-py3-none-any.whl", hash = "sha256:2fd27e9a2d54ebcd915ac5ea51d79c772e020567ef6c6a76678182055489b804", size = 165363, upload-time = "2026-10-08T22:14:09.321Z" },
 ]
 
 [[package]]
@@ -1711,7 +1711,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.6.6"
+version = "1.6.9"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1725,14 +1725,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/18/87/9e5d393bbcec068c51becc255a15aacfd8a14ac5826179751c1c320e5258/langchain_core-1.6.6.tar.gz", hash = "sha256:67616d984c085009be2c381c2efd330d32429a58aebab295b4f51b6573964511", size = 1007227, upload-time = "2026-09-29T14:52:54.598Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/d3/e9611e44e62ab8175127e137587c62dc2ed00e2615aebd89dfdb77f5fba0/langchain_core-1.6.9.tar.gz", hash = "sha256:34394228603e6f0bd24ce4e773b58b7d160e1b8cf489ecb350cf41f5366f5e92", size = 1010051, upload-time = "2026-10-08T20:11:19.881Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/10/8c00b4dc094886314c907ec7ead258dfee28948cf44175976cc4fba9aba8/langchain_core-1.6.6-py3-none-any.whl", hash = "sha256:d9a71e312ab7443701238750e04a57aefc037c4f1ec82837c8a1609d9a14a9b1", size = 572080, upload-time = "2026-09-29T14:52:53.213Z" },
+    { url = "https://files.pythonhosted.org/packages/49/41/fdcdd869c052874b17e2325c986cf8c2fc6bbefa3b9d5404dd64dfffb12a/langchain_core-1.6.9-py3-none-any.whl", hash = "sha256:2bacea12270fd4cfdeeefdc5977e7e8b3c30814c509534d1ef43f4e5b7d3f657", size = 572951, upload-time = "2026-10-08T20:11:18.189Z" },
 ]
 
 [[package]]
 name = "langchain-openai"
-version = "1.6.7"
+version = "1.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -1740,9 +1740,9 @@ dependencies = [
     { name = "openai" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7c/2f/367068190b5a7d181996ad7899052394f0276468c92be48e0b7dab63716a/langchain_openai-1.6.7.tar.gz", hash = "sha256:b276a01b43c5287382f62070a4e1ca5bad5581fadab8c086e46b79daa4bf975d", size = 3380633, upload-time = "2026-09-30T15:12:03.1Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/68/dd7f7ef76efe58222d37f1b1a5595b1bb368fc9165f71526db26e4c5759e/langchain_openai-1.7.0.tar.gz", hash = "sha256:7df2db16d32320ba563b7e4291a71ec6bf7b0ea8a5369ed2a0501d74928ea6d0", size = 3404806, upload-time = "2026-10-08T16:07:35.135Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/d9/b3db61c6c15766c999194a9cba0b9c5035567b7e0dd1c1a94a6d76448cd6/langchain_openai-1.6.7-py3-none-any.whl", hash = "sha256:e1b9b318fafc47b2dbc3485778aa23f809195065ee313611c188af29744b8e8e", size = 127883, upload-time = "2026-09-30T15:12:01.876Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ef/3f40387231281eaefb0bec31bfa86a7d533de9d90b46802c3e24d436a163/langchain_openai-1.7.0-py3-none-any.whl", hash = "sha256:a4d319385019c010c579b39e8951e4d5ededeacf94cd9c79162f4cb7ecba50fb", size = 145622, upload-time = "2026-10-08T16:07:33.119Z" },
 ]
 
 [[package]]
@@ -1771,7 +1771,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.13"
+version = "1.2.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
@@ -1781,9 +1781,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "xxhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/22/75ab5e7d13c842d8dc68f115cf6cc5a651a8d5a993e72a621c98bfb2b1cd/langgraph-1.2.13.tar.gz", hash = "sha256:a3cae71d4cb88455d7a8887109665525aefe4ab13fe941d653cd4b6de2af45c6", size = 752793, upload-time = "2026-10-05T17:51:21.566Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/3f/6e60789eab2c5ceaf34ba2c626ac345df93b026bbe7385018aa4b9c30397/langgraph-1.2.14.tar.gz", hash = "sha256:5b1a72b7a7f994ac6947b7751fbbe00e949f8bb44d9ab78881604b703247ae55", size = 752793, upload-time = "2026-10-06T14:41:19.789Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/da/8e/b7471af7fc72c218e545c74454c386a4b0867a8a15c9893db1d28464f492/langgraph-1.2.13-py3-none-any.whl", hash = "sha256:5d45a021e043aaf39f32122e620eacfd1245aa84dfaa84b0814cef0f4ac78eb4", size = 255979, upload-time = "2026-10-05T17:51:20.221Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4a/f976df0d3cf7fb7986dc39f656c6b7b5655834430e9bdfaef1e1e4fffaba/langgraph-1.2.14-py3-none-any.whl", hash = "sha256:e3f5f8ff4259f9281b73ff50fc9ef5cc3b025b8936b8283ecdca7cc0c4128690", size = 255980, upload-time = "2026-10-06T14:41:18.129Z" },
 ]
 
 [[package]]
@@ -1814,7 +1814,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.4.4"
+version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1823,9 +1823,9 @@ dependencies = [
     { name = "orjson" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3f/ae/91446c1fffa04a2dc1f81afbfb5bfff3590452891a72bd9098a656ab2657/langgraph_sdk-0.4.4.tar.gz", hash = "sha256:4e651ffa09de695681579396375377bdde23bedbc8e35b070e615cbd5af7da8b", size = 345789, upload-time = "2026-08-27T21:25:22.593Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/85/54edf4902c0378510f09a009f64e3d3f5644aeeb51d13cf67ec380a5245b/langgraph_sdk-0.4.6.tar.gz", hash = "sha256:ea5b1749d70987d741c9b9fe2b7e1c5f7da7e4d102f64e390333c1890c9bbd5b", size = 350632, upload-time = "2026-10-06T14:17:53.641Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/d5/2ad7f3a835c6fcebf58b6669552536ecd52d2dfe4cf49c6c36648fd83572/langgraph_sdk-0.4.4-py3-none-any.whl", hash = "sha256:39afe416c91742925e6f8a93715f566d499b36e1b636b804a4ffe3190e4f4e64", size = 162270, upload-time = "2026-08-27T21:25:21.072Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/c7/69d13026db3577c157877dea47a9dc5fffd3dcde2d1ab8009fa8f7e5f6a6/langgraph_sdk-0.4.6-py3-none-any.whl", hash = "sha256:57122b02bda41d37a97a5e09eb018aa8c9b3dc85c433880073779bd9324b7eea", size = 162390, upload-time = "2026-10-06T14:17:52.134Z" },
 ]
 
 [[package]]

From b086f65437c4904310279646da76321a80294056 Mon Sep 17 00:00:00 2001
From: Radu Raicea <radu@raicea.com>
Date: Mon, 19 Oct 2026 15:18:22 -0400
Subject: [PATCH 047/245] feat(llma): support scorer and experiment tags
 (#1085)

---
 .sampo/changesets/evaluation-tags.md          |  5 +
 .../example-offline-evaluations/README.md     | 37 ++++++++
 posthog/ai/evaluations/_client.py             | 50 ++++++++++
 posthog/ai/evaluations/_scorer_types.py       |  2 +
 posthog/ai/evaluations/_scorers.py            | 67 ++++++++++---
 posthog/ai/evaluations/_tags.py               | 28 ++++++
 posthog/test/ai/test_evaluations.py           | 95 +++++++++++++++++++
 posthog/test/ai/test_evaluations_scorers.py   | 92 ++++++++++++++++++
 references/public_api_snapshot.txt            | 19 ++--
 9 files changed, 376 insertions(+), 19 deletions(-)
 create mode 100644 .sampo/changesets/evaluation-tags.md
 create mode 100644 posthog/ai/evaluations/_tags.py

diff --git a/.sampo/changesets/evaluation-tags.md b/.sampo/changesets/evaluation-tags.md
new file mode 100644
index 000000000..ea734ed30
--- /dev/null
+++ b/.sampo/changesets/evaluation-tags.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Support tags in synchronous and asynchronous AI observability scorer creation, metadata updates, responses, and list filters. Add `get_tags()` and `set_tags()` to offline experiment handles for reading, replacing, and clearing experiment tags independently of uploads and completion.
diff --git a/examples/example-offline-evaluations/README.md b/examples/example-offline-evaluations/README.md
index c1ec2207f..279fe4e70 100644
--- a/examples/example-offline-evaluations/README.md
+++ b/examples/example-offline-evaluations/README.md
@@ -11,6 +11,8 @@ Offline evaluations must be enabled for your PostHog project. Use the project's
 | Create experiments, upload results, complete/fail | Personal API key or project secret key with `offline_evaluation_ingestion:write` |
 | Fetch scorers and versions | Personal API key with `llm_analytics:read` |
 | Create/update scorers and create versions | Personal API key with `llm_analytics:write` |
+| Read experiment tags | Personal API key with `evaluation:read` |
+| Replace experiment tags | Personal API key with `evaluation:write` |
 
 A personal key can cover both scorer management and uploads. Project secret keys can upload using a known scorer-version UUID without scorer read access. All operations use the explicit project/environment; scorer names are not unique.
 
@@ -147,6 +149,41 @@ version = evaluations.scorers.get_version(scorer.id, updated.current_version_id)
 
 Scorer creation, version creation, and metadata updates are never automatically retried. If a response is lost, inspect server state before repeating a mutation. Version creation is not made idempotent by `base_version`.
 
+## Tags
+
+Assign tags when creating a scorer, or replace them with a metadata update:
+
+```python
+scorer = evaluations.scorers.create(
+    name="Answer relevance",
+    kind="numeric",
+    config=NumericScorerConfig(min=0, max=1),
+    tags=["quality", "production"],
+)
+print(scorer.tags)  # ("production", "quality")
+scorer = evaluations.scorers.update(scorer.id, tags=["quality"])
+page = evaluations.scorers.list(tags=["quality", "production"], tag_match="all")
+evaluations.scorers.update(scorer.id, tags=[])  # Remove all tags.
+```
+
+Omitting `tags` preserves existing tags on updates. `tags=[]` clears them; `None` is not a valid replacement. Lists and tuples are accepted. The server trims and lowercases names, removes duplicates, and sorts them. Returned tags are immutable tuples. Writes accept up to 100 names, each nonblank and at most 255 characters after trimming.
+
+List filters accept up to 20 tags. `tag_match="any"` (the default) matches at least one selected tag; `"all"` requires every selected tag. An empty filter disables tag filtering. Preserve these filters when requesting subsequent pages.
+
+Experiment tags are separate from the creation/upload declaration. Set them on a newly created or resumed handle, including after completion:
+
+```python
+experiment = evaluations.resume_experiment(experiment_id)
+tags = experiment.set_tags(["quality", "baseline"])
+print(tags)  # ("baseline", "quality")
+print(experiment.get_tags())
+experiment.set_tags([])  # Remove all tags.
+```
+
+Reading and writing experiment tags require the personal-key scopes listed above; an upload-only project secret key cannot manage tags. Tag updates do not change the saved `submission`, lifecycle `receipt`, or scorer versions. They are not retried automatically: after a lost acknowledgment, read the current tags before deciding whether to repeat the replacement, since another caller may have edited them.
+
+The async client exposes the same API: await scorer methods and `experiment.get_tags()` / `experiment.set_tags(...)`.
+
 ## Receipts, errors, and recovery
 
 Upload receipts contain persisted item/result UUIDs, original acceptance times, and `created` flags. `created=False` acknowledges an exact duplicate. A bulk upload returns `chunks`; each chunk commits independently. A malformed or incomplete acknowledgment raises rather than reporting success.
diff --git a/posthog/ai/evaluations/_client.py b/posthog/ai/evaluations/_client.py
index 9e7c75c56..69fc622cb 100644
--- a/posthog/ai/evaluations/_client.py
+++ b/posthog/ai/evaluations/_client.py
@@ -23,6 +23,7 @@
     _timestamp,
     _uuid,
 )
+from ._tags import _response_tags, _tag_names
 from ._transport import AsyncTransport, SyncTransport
 from ._types import (
     BulkUploadError,
@@ -38,6 +39,20 @@
 )
 
 
+def _experiment_tags(data: dict[str, Any], identity: str) -> tuple[str, ...]:
+    try:
+        if _uuid(data["id"]) != identity:
+            raise ValueError("Mismatched experiment ID.")
+        return _response_tags(data["tags"])
+    except (KeyError, TypeError, ValueError):
+        raise EvaluationAPIError(
+            code="invalid_response",
+            detail="The experiment API returned invalid tag metadata.",
+            response=data,
+            persistence="unknown",
+        ) from None
+
+
 def _experiment_body(name: str, options: ExperimentOptions) -> bytes:
     allowed = set(ExperimentOptions.__annotations__)
     if set(options) - allowed:
@@ -179,6 +194,26 @@ def submission(self) -> dict[str, Any] | None:
         """Copy of original creation fields; unavailable on a resumed handle."""
         return None if self._submission is None else json.loads(self._submission)
 
+    def get_tags(self) -> tuple[str, ...]:
+        """Fetch current tags using a personal key with ``evaluation:read``."""
+        with self._lock:
+            data = self._transport.request("GET", self._path)
+            return _experiment_tags(data, self.id)
+
+    def set_tags(self, tags: Sequence[str]) -> tuple[str, ...]:
+        """Replace tags and return the server's normalized names; [] clears them.
+
+        Requires a personal key with ``evaluation:write``. Tags can change after
+        completion and are separate from the immutable creation ``submission``.
+        Updates are not retried automatically: inspect tags after a lost response.
+        """
+        body = _encode({"tags": _tag_names(tags)})
+        with self._lock:
+            data = self._transport.request(
+                "PATCH", self._path, body=body, retry_safe=False
+            )
+            return _experiment_tags(data, self.id)
+
     def upload_result(
         self,
         *,
@@ -289,6 +324,21 @@ def submission(self) -> dict[str, Any] | None:
         """Copy of original creation fields; unavailable on a resumed handle."""
         return None if self._submission is None else json.loads(self._submission)
 
+    async def get_tags(self) -> tuple[str, ...]:
+        """Fetch current tags. See Experiment.get_tags for key requirements."""
+        async with self._lock:
+            data = await self._transport.request("GET", self._path)
+            return _experiment_tags(data, self.id)
+
+    async def set_tags(self, tags: Sequence[str]) -> tuple[str, ...]:
+        """Replace tags. See Experiment.set_tags for permissions and recovery."""
+        body = _encode({"tags": _tag_names(tags)})
+        async with self._lock:
+            data = await self._transport.request(
+                "PATCH", self._path, body=body, retry_safe=False
+            )
+            return _experiment_tags(data, self.id)
+
     async def upload_result(
         self,
         *,
diff --git a/posthog/ai/evaluations/_scorer_types.py b/posthog/ai/evaluations/_scorer_types.py
index 6dd204541..e7aedd95b 100644
--- a/posthog/ai/evaluations/_scorer_types.py
+++ b/posthog/ai/evaluations/_scorer_types.py
@@ -96,6 +96,7 @@ class Scorer(Generic[_ConfigT]):
     Read ``current_version_id`` once to pin the version for an experiment.
     Names are not unique; use ``id`` for subsequent management operations.
     Configuration dictionaries are local snapshots, not live server state.
+    ``tags`` contains normalized tag names and is independent of versions.
     """
 
     id: str
@@ -110,6 +111,7 @@ class Scorer(Generic[_ConfigT]):
     updated_at: datetime
     created_by: dict[str, Any] | None
     team: int
+    tags: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
diff --git a/posthog/ai/evaluations/_scorers.py b/posthog/ai/evaluations/_scorers.py
index 2c5dc3d10..1d9e15483 100644
--- a/posthog/ai/evaluations/_scorers.py
+++ b/posthog/ai/evaluations/_scorers.py
@@ -5,7 +5,7 @@
 import copy
 import json
 from datetime import datetime
-from typing import Any, Callable, Literal, TypeVar, cast, overload
+from typing import Any, Callable, Literal, Sequence, TypeVar, cast, overload
 from urllib.parse import parse_qs, urlsplit
 from uuid import UUID
 
@@ -22,6 +22,7 @@
     ScorerVersion,
     ScorerVersionPage,
 )
+from ._tags import _response_tags, _tag_names
 from ._transport import AsyncTransport, SyncTransport
 
 
@@ -100,6 +101,7 @@ def _scorer(data: dict[str, Any]) -> Scorer[ScorerConfig]:
         updated_at=_timestamp(data["updated_at"]),
         created_by=None if created_by is None else _mapping(created_by),
         team=_integer(data["team"], minimum=1),
+        tags=_response_tags(data.get("tags", [])),
     )
 
 
@@ -176,6 +178,7 @@ def _create_body(
     kind: ScorerKind,
     config: ScorerConfig,
     description: str | None | _Omitted,
+    tags: Sequence[str] | _Omitted,
 ) -> bytes:
     data: dict[str, Any] = {
         "name": name,
@@ -184,6 +187,8 @@ def _create_body(
     }
     if not isinstance(description, _Omitted):
         data["description"] = description
+    if not isinstance(tags, _Omitted):
+        data["tags"] = _tag_names(tags)
     return _encode(data)
 
 
@@ -191,8 +196,9 @@ def _metadata(
     name: str | _Omitted,
     description: str | None | _Omitted,
     archived: bool | _Omitted = _OMITTED,
+    tags: Sequence[str] | _Omitted = _OMITTED,
 ) -> dict[str, Any]:
-    return {
+    data: dict[str, Any] = {
         key: value
         for key, value in {
             "name": name,
@@ -201,6 +207,9 @@ def _metadata(
         }.items()
         if not isinstance(value, _Omitted)
     }
+    if not isinstance(tags, _Omitted):
+        data["tags"] = _tag_names(tags)
+    return data
 
 
 def _version_body(
@@ -223,7 +232,11 @@ def _list_params(
     kind: ScorerKind | None,
     archived: bool | None,
     order_by: ScorerOrder | None,
+    tags: Sequence[str] | None,
+    tag_match: Literal["any", "all"],
 ) -> dict[str, str | int]:
+    if tag_match not in ("any", "all"):
+        raise ValueError("tag_match must be any or all.")
     params: dict[str, str | int] = {
         "limit": _integer(limit, minimum=1),
         "offset": _integer(offset),
@@ -238,6 +251,11 @@ def _list_params(
         params["archived"] = "true" if archived else "false"
     if order_by is not None:
         params["order_by"] = order_by
+    if tags is not None:
+        params["tags"] = json.dumps(_tag_names(tags, limit=20), ensure_ascii=False)
+        params["tag_match"] = tag_match
+    elif tag_match != "any":
+        params["tag_match"] = tag_match
     return params
 
 
@@ -273,6 +291,7 @@ def create(
         kind: Literal["boolean"],
         config: BooleanScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[BooleanScorerConfig]: ...
 
     @overload
@@ -283,6 +302,7 @@ def create(
         kind: Literal["numeric"],
         config: NumericScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[NumericScorerConfig]: ...
 
     @overload
@@ -293,6 +313,7 @@ def create(
         kind: Literal["categorical"],
         config: CategoricalScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[CategoricalScorerConfig]: ...
 
     def create(
@@ -302,14 +323,18 @@ def create(
         kind: ScorerKind,
         config: ScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[ScorerConfig]:
-        """Create an active scorer and its first immutable configuration version."""
+        """Create a scorer and its first version, optionally assigning tags.
+
+        Tag names are trimmed, lowercased, deduplicated, and sorted by the server.
+        """
         return _parse(
             _scorer,
             self._transport.request(
                 "POST",
                 self._base,
-                body=_create_body(name, kind, config, description),
+                body=_create_body(name, kind, config, description, tags),
                 retry_safe=False,
             ),
         )
@@ -327,18 +352,24 @@ def list(
         kind: ScorerKind | None = None,
         archived: bool | None = None,
         order_by: ScorerOrder | None = None,
+        tags: Sequence[str] | None = None,
+        tag_match: Literal["any", "all"] = "any",
     ) -> ScorerPage:
         """Fetch one page. Omit ``archived`` to list active scorers.
 
         Keep the same filters and pass the returned ``next_offset`` to continue.
         Search matches names and descriptions; scorer names are not unique.
+        ``tags`` accepts up to 20 names. ``tag_match`` matches any (default) or
+        all selected tags; an empty sequence disables tag filtering.
         """
         return _parse(
             _scorer_page,
             self._transport.request(
                 "GET",
                 self._base,
-                params=_list_params(limit, offset, search, kind, archived, order_by),
+                params=_list_params(
+                    limit, offset, search, kind, archived, order_by, tags, tag_match
+                ),
             ),
         )
 
@@ -349,17 +380,20 @@ def update(
         name: str | _Omitted = _OMITTED,
         description: str | None | _Omitted = _OMITTED,
         archived: bool | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[ScorerConfig]:
         """Update metadata. Use ``create_version`` to change configuration.
 
         Omitted fields are preserved. An explicit null description clears it.
+        ``tags`` replaces the current tags; pass [] to clear them. Tag changes
+        do not create a scorer version.
         """
         return _parse(
             _scorer,
             self._transport.request(
                 "PATCH",
                 self._path(scorer_id),
-                body=_encode(_metadata(name, description, archived)),
+                body=_encode(_metadata(name, description, archived, tags)),
                 retry_safe=False,
             ),
         )
@@ -435,6 +469,7 @@ async def create(
         kind: Literal["boolean"],
         config: BooleanScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[BooleanScorerConfig]: ...
 
     @overload
@@ -445,6 +480,7 @@ async def create(
         kind: Literal["numeric"],
         config: NumericScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[NumericScorerConfig]: ...
 
     @overload
@@ -455,6 +491,7 @@ async def create(
         kind: Literal["categorical"],
         config: CategoricalScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[CategoricalScorerConfig]: ...
 
     async def create(
@@ -464,14 +501,15 @@ async def create(
         kind: ScorerKind,
         config: ScorerConfig,
         description: str | None | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[ScorerConfig]:
-        """Create an active scorer and its first version; never retry mutations."""
+        """Create a scorer with optional tags. See Scorers.create."""
         return _parse(
             _scorer,
             await self._transport.request(
                 "POST",
                 self._base,
-                body=_create_body(name, kind, config, description),
+                body=_create_body(name, kind, config, description, tags),
                 retry_safe=False,
             ),
         )
@@ -491,14 +529,18 @@ async def list(
         kind: ScorerKind | None = None,
         archived: bool | None = None,
         order_by: ScorerOrder | None = None,
+        tags: Sequence[str] | None = None,
+        tag_match: Literal["any", "all"] = "any",
     ) -> ScorerPage:
-        """Fetch one page; preserve filters and use ``next_offset`` to continue."""
+        """Fetch one page with optional tag filters. See Scorers.list."""
         return _parse(
             _scorer_page,
             await self._transport.request(
                 "GET",
                 self._base,
-                params=_list_params(limit, offset, search, kind, archived, order_by),
+                params=_list_params(
+                    limit, offset, search, kind, archived, order_by, tags, tag_match
+                ),
             ),
         )
 
@@ -509,14 +551,15 @@ async def update(
         name: str | _Omitted = _OMITTED,
         description: str | None | _Omitted = _OMITTED,
         archived: bool | _Omitted = _OMITTED,
+        tags: Sequence[str] | _Omitted = _OMITTED,
     ) -> Scorer[ScorerConfig]:
-        """Update metadata; omission preserves values and null clears description."""
+        """Update metadata, including replacement tags. See Scorers.update."""
         return _parse(
             _scorer,
             await self._transport.request(
                 "PATCH",
                 self._path(scorer_id),
-                body=_encode(_metadata(name, description, archived)),
+                body=_encode(_metadata(name, description, archived, tags)),
                 retry_safe=False,
             ),
         )
diff --git a/posthog/ai/evaluations/_tags.py b/posthog/ai/evaluations/_tags.py
new file mode 100644
index 000000000..be1448f70
--- /dev/null
+++ b/posthog/ai/evaluations/_tags.py
@@ -0,0 +1,28 @@
+"""Shared validation for mutable scorer and experiment tags."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+
+def _tag_names(tags: Sequence[str], *, limit: int = 100) -> list[str]:
+    if isinstance(tags, (str, bytes)) or not isinstance(tags, Sequence):
+        raise ValueError("tags must be a sequence of strings.")
+    if len(tags) > limit:
+        raise ValueError(f"tags must contain at most {limit} names.")
+    names = list(tags)
+    for name in names:
+        if not isinstance(name, str) or not name.strip() or len(name.strip()) > 255:
+            raise ValueError(
+                "Each tag must be a nonblank string of at most 255 characters."
+            )
+    # The server trims, lowercases, deduplicates, and sorts names. Preserve the
+    # caller's spelling on the wire and return the server's canonical response.
+    return names
+
+
+def _response_tags(value: Any) -> tuple[str, ...]:
+    if not isinstance(value, list) or any(not isinstance(tag, str) for tag in value):
+        raise ValueError("Expected a list of tag names.")
+    return tuple(value)
diff --git a/posthog/test/ai/test_evaluations.py b/posthog/test/ai/test_evaluations.py
index f6f2f96f9..b2e76d0eb 100644
--- a/posthog/test/ai/test_evaluations.py
+++ b/posthog/test/ai/test_evaluations.py
@@ -114,6 +114,101 @@ def result(item=None, **kwargs):
     )
 
 
+def test_experiment_tags_are_separate_from_creation_and_lifecycle_receipts(client):
+    evaluations, transport = client
+    experiment = invoke(evaluations.create_experiment, name="Tagged run")
+    invoke(experiment.complete)
+    submission, receipt = experiment.submission, experiment.receipt
+    transport.request.reset_mock()
+    transport.request.side_effect = None
+    response = {
+        "id": experiment.id,
+        "status": "completed",
+        "tags": ["production", "quality"],
+    }
+    transport.request.return_value = response
+    tags = invoke(experiment.set_tags, [" Quality ", "production", "Quality"])
+    assert tags == ("production", "quality")
+    transport.request.assert_called_once_with(
+        "PATCH",
+        BASE + experiment.id + "/",
+        body=b'{"tags":[" Quality ","production","Quality"]}',
+        retry_safe=False,
+    )
+    response["tags"].append("later")
+    assert tags == ("production", "quality")
+    assert experiment.receipt is receipt
+    assert experiment.submission == submission
+    assert "tags" not in experiment.submission
+
+    response["tags"] = []
+    assert invoke(experiment.set_tags, ()) == ()
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {"tags": []}
+    assert invoke(experiment.get_tags) == ()
+    transport.request.assert_called_with("GET", BASE + experiment.id + "/")
+
+
+def test_resumed_experiment_can_fetch_tags(client):
+    evaluations, transport = client
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    transport.request.assert_not_called()
+    transport.request.side_effect = None
+    transport.request.return_value = {"id": EXPERIMENT_ID, "tags": ["quality"]}
+    assert invoke(experiment.get_tags) == ("quality",)
+    assert experiment.receipt is None
+    assert experiment.submission is None
+
+
+@pytest.mark.parametrize(
+    "tags", [None, "quality", {"quality"}, [1], [""], [" "], ["x" * 256], ["q"] * 101]
+)
+def test_invalid_experiment_tags_are_rejected_before_io(client, tags):
+    evaluations, transport = client
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    with pytest.raises(ValueError):
+        invoke(experiment.set_tags, tags)
+    transport.request.assert_not_called()
+
+
+@pytest.mark.parametrize("operation", ["get_tags", "set_tags"])
+@pytest.mark.parametrize(
+    "response",
+    [
+        {"id": EXPERIMENT_ID},
+        {"id": EXPERIMENT_ID, "tags": None},
+        {"id": EXPERIMENT_ID, "tags": "quality"},
+        {"id": EXPERIMENT_ID, "tags": [1]},
+        {"tags": []},
+        {"id": VERSION_ID, "tags": []},
+    ],
+)
+def test_malformed_experiment_tag_responses_are_not_acknowledged(
+    client, operation, response
+):
+    evaluations, transport = client
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    transport.request.side_effect = None
+    transport.request.return_value = response
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(
+            getattr(experiment, operation), *([[]] if operation == "set_tags" else [])
+        )
+    assert caught.value.code == "invalid_response"
+    assert caught.value.persistence == "unknown"
+    assert caught.value.response == response
+
+
+def test_experiment_tag_permission_error_is_preserved(client):
+    evaluations, transport = client
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    error = EvaluationAPIError(status=403, persistence="rejected")
+    transport.request.side_effect = error
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(experiment.set_tags, ["quality"])
+    assert caught.value is error
+    transport.request.assert_called_once()
+
+
 def test_create_upload_and_explicit_completion(client):
     evaluations, transport = client
     experiment = invoke(
diff --git a/posthog/test/ai/test_evaluations_scorers.py b/posthog/test/ai/test_evaluations_scorers.py
index 128834c0f..9fa40e918 100644
--- a/posthog/test/ai/test_evaluations_scorers.py
+++ b/posthog/test/ai/test_evaluations_scorers.py
@@ -174,6 +174,98 @@ def test_metadata_update_preserves_omission_null_and_false(scorers):
     assert json.loads(transport.request.call_args.kwargs["body"]) == {"name": "Renamed"}
 
 
+@pytest.mark.parametrize("tags", [[" Quality ", "production", "Quality"], (), []])
+@pytest.mark.parametrize("operation", ["create", "update"])
+def test_tags_are_mutable_metadata_with_normalized_response(scorers, tags, operation):
+    namespace, transport = scorers
+    normalized = sorted({tag.strip().lower() for tag in tags})
+    transport.request.return_value = scorer_response(tags=normalized)
+    if operation == "create":
+        scorer = invoke(
+            namespace.create, name="Quality", kind="numeric", config={}, tags=tags
+        )
+    else:
+        scorer = invoke(namespace.update, SCORER_ID, tags=tags)
+        assert json.loads(transport.request.call_args.kwargs["body"]) == {
+            "tags": list(tags)
+        }
+    assert json.loads(transport.request.call_args.kwargs["body"])["tags"] == list(tags)
+    assert transport.request.call_args.kwargs["retry_safe"] is False
+    assert scorer.tags == tuple(normalized)
+    assert scorer.current_version_id == VERSION_ID
+    normalized.append("later")
+    assert "later" not in scorer.tags
+    transport.request.assert_called_once()
+
+
+def test_scorer_tags_are_optional_for_older_servers(scorers):
+    namespace, _ = scorers
+    assert invoke(namespace.get, SCORER_ID).tags == ()
+
+
+@pytest.mark.parametrize("tags", [None, "quality", [None], [1], {}])
+def test_invalid_scorer_response_tags_raise(scorers, tags):
+    namespace, transport = scorers
+    transport.request.return_value = scorer_response(tags=tags)
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(namespace.get, SCORER_ID)
+    assert caught.value.code == "invalid_response"
+    assert caught.value.persistence == "unknown"
+
+
+@pytest.mark.parametrize("tag_match", ["any", "all"])
+@pytest.mark.parametrize("tags", [[], ("quality", 'a,b"c', "品質")])
+def test_scorer_list_tag_filters_use_json_and_preserve_other_filters(
+    scorers, tags, tag_match
+):
+    namespace, transport = scorers
+    transport.request.return_value = {
+        "count": 1,
+        "next": None,
+        "previous": None,
+        "results": [scorer_response(tags=["quality"])],
+    }
+    page = invoke(
+        namespace.list, tags=tags, tag_match=tag_match, offset=3, search="score"
+    )
+    params = transport.request.call_args.kwargs["params"]
+    assert json.loads(params["tags"]) == list(tags)
+    assert params["tag_match"] == tag_match
+    assert params["offset"] == 3
+    assert params["search"] == "score"
+    assert page.results[0].tags == ("quality",)
+
+
+@pytest.mark.parametrize("operation", ["create", "update", "list"])
+@pytest.mark.parametrize(
+    "tags", ["quality", {"quality": True}, [1], [None], [" "], ["x" * 256]]
+)
+def test_invalid_tag_names_fail_before_scorer_request(scorers, tags, operation):
+    namespace, transport = scorers
+    with pytest.raises(ValueError):
+        if operation == "create":
+            invoke(namespace.create, name="Score", kind="numeric", config={}, tags=tags)
+        elif operation == "update":
+            invoke(namespace.update, SCORER_ID, tags=tags)
+        else:
+            invoke(namespace.list, tags=tags)
+    transport.request.assert_not_called()
+
+
+def test_tag_count_limits_and_null_writes_are_rejected(scorers):
+    namespace, transport = scorers
+    for tags in (None, ["quality"] * 101):
+        with pytest.raises(ValueError):
+            invoke(namespace.create, name="Score", kind="numeric", config={}, tags=tags)
+        with pytest.raises(ValueError):
+            invoke(namespace.update, SCORER_ID, tags=tags)
+    with pytest.raises(ValueError):
+        invoke(namespace.list, tags=["quality"] * 21)
+    with pytest.raises(ValueError):
+        invoke(namespace.list, tag_match="invalid")
+    transport.request.assert_not_called()
+
+
 def test_version_bump_preserves_configuration_and_concurrency_guard(scorers):
     namespace, transport = scorers
     config = NumericScorerConfig(min=0, max=1)
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 29a1c477e..5a093b650 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -486,6 +486,7 @@ attribute posthog.ai.evaluations.Scorer.description: str
 attribute posthog.ai.evaluations.Scorer.id: str
 attribute posthog.ai.evaluations.Scorer.kind: ScorerKind
 attribute posthog.ai.evaluations.Scorer.name: str
+attribute posthog.ai.evaluations.Scorer.tags: tuple[str, ...] = ()
 attribute posthog.ai.evaluations.Scorer.team: int
 attribute posthog.ai.evaluations.Scorer.updated_at: datetime
 attribute posthog.ai.evaluations.ScorerConfig = BooleanScorerConfig | NumericScorerConfig | CategoricalScorerConfig
@@ -1148,7 +1149,7 @@ class posthog.ai.evaluations.NumericScorerConfig
 class posthog.ai.evaluations.OfflineEvaluations(*, project_id: int, secret_key: str, host: str | None = None, timeout: float = 15, max_retries: int = 3)
 class posthog.ai.evaluations.ResultOptions
 class posthog.ai.evaluations.ResultReceipt(id: str, created: bool, accepted_at: datetime, item_id: str, scorer_version_id: str)
-class posthog.ai.evaluations.Scorer(id: str, name: str, description: str, kind: ScorerKind, archived: bool, current_version: int, current_version_id: str, config: _ConfigT, created_at: datetime, updated_at: datetime, created_by: dict[str, Any] | None, team: int)
+class posthog.ai.evaluations.Scorer(id: str, name: str, description: str, kind: ScorerKind, archived: bool, current_version: int, current_version_id: str, config: _ConfigT, created_at: datetime, updated_at: datetime, created_by: dict[str, Any] | None, team: int, tags: tuple[str, ...] = ())
 class posthog.ai.evaluations.ScorerPage(count: int, results: tuple[Scorer[ScorerConfig], ...], next: str | None, previous: str | None, next_offset: int | None)
 class posthog.ai.evaluations.ScorerVersion(id: str, definition_id: str, version: int, kind: ScorerKind, config: _ConfigT, created_at: datetime, created_by: dict[str, Any] | None)
 class posthog.ai.evaluations.ScorerVersionPage(count: int, results: tuple[ScorerVersion[ScorerConfig], ...], next_cursor: str | None)
@@ -1502,36 +1503,40 @@ method posthog.ai.claude_agent_sdk.client.PostHogClaudeSDKClient.set_permission_
 method posthog.ai.claude_agent_sdk.processor.PostHogClaudeAgentProcessor.query(*, prompt: Any, options: Optional[ClaudeAgentOptions] = None, transport: Any = None, posthog_distinct_id: Optional[Union[str, Callable[[ResultMessage], Optional[str]]]] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: Optional[bool] = None, posthog_groups: Optional[Dict[str, Any]] = None)
 method posthog.ai.evaluations.AsyncExperiment.complete()
 method posthog.ai.evaluations.AsyncExperiment.fail()
+method posthog.ai.evaluations.AsyncExperiment.get_tags()
+method posthog.ai.evaluations.AsyncExperiment.set_tags(tags: Sequence[str])
 method posthog.ai.evaluations.AsyncExperiment.upload_result(*, item: EvaluationItem | str | UUID, scorer_version_id: str | UUID, **options: Unpack[ResultOptions])
 method posthog.ai.evaluations.AsyncExperiment.upload_results(results: Sequence[EvaluationResult])
 method posthog.ai.evaluations.AsyncOfflineEvaluations.aclose()
 method posthog.ai.evaluations.AsyncOfflineEvaluations.create_experiment(*, name: str, **options: Unpack[ExperimentOptions])
 method posthog.ai.evaluations.AsyncOfflineEvaluations.resume_experiment(id: str | UUID)
-method posthog.ai.evaluations.AsyncScorers.create(*, name: str, kind: ScorerKind, config: ScorerConfig, description: str | None | _Omitted = _OMITTED)
+method posthog.ai.evaluations.AsyncScorers.create(*, name: str, kind: ScorerKind, config: ScorerConfig, description: str | None | _Omitted = _OMITTED, tags: Sequence[str] | _Omitted = _OMITTED)
 method posthog.ai.evaluations.AsyncScorers.create_version(scorer_id: str | UUID, *, config: _ConfigT, base_version: int | None = None, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED)
 method posthog.ai.evaluations.AsyncScorers.get(scorer_id: str | UUID)
 method posthog.ai.evaluations.AsyncScorers.get_version(scorer_id: str | UUID, version_id: str | UUID)
-method posthog.ai.evaluations.AsyncScorers.list(*, limit: int = 100, offset: int = 0, search: str | None = None, kind: ScorerKind | None = None, archived: bool | None = None, order_by: ScorerOrder | None = None)
+method posthog.ai.evaluations.AsyncScorers.list(*, limit: int = 100, offset: int = 0, search: str | None = None, kind: ScorerKind | None = None, archived: bool | None = None, order_by: ScorerOrder | None = None, tags: Sequence[str] | None = None, tag_match: Literal['any', 'all'] = 'any')
 method posthog.ai.evaluations.AsyncScorers.list_versions(scorer_id: str | UUID, *, limit: int = 50, cursor: str | None = None)
-method posthog.ai.evaluations.AsyncScorers.update(scorer_id: str | UUID, *, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED, archived: bool | _Omitted = _OMITTED)
+method posthog.ai.evaluations.AsyncScorers.update(scorer_id: str | UUID, *, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED, archived: bool | _Omitted = _OMITTED, tags: Sequence[str] | _Omitted = _OMITTED)
 method posthog.ai.evaluations.EvaluationItem.from_dict(data: Mapping[str, Any])
 method posthog.ai.evaluations.EvaluationItem.to_dict()
 method posthog.ai.evaluations.EvaluationResult.from_dict(data: Mapping[str, Any], *, item: EvaluationItem | None = None)
 method posthog.ai.evaluations.EvaluationResult.to_dict()
 method posthog.ai.evaluations.Experiment.complete()
 method posthog.ai.evaluations.Experiment.fail()
+method posthog.ai.evaluations.Experiment.get_tags()
+method posthog.ai.evaluations.Experiment.set_tags(tags: Sequence[str])
 method posthog.ai.evaluations.Experiment.upload_result(*, item: EvaluationItem | str | UUID, scorer_version_id: str | UUID, **options: Unpack[ResultOptions])
 method posthog.ai.evaluations.Experiment.upload_results(results: Sequence[EvaluationResult])
 method posthog.ai.evaluations.OfflineEvaluations.close()
 method posthog.ai.evaluations.OfflineEvaluations.create_experiment(*, name: str, **options: Unpack[ExperimentOptions])
 method posthog.ai.evaluations.OfflineEvaluations.resume_experiment(id: str | UUID)
-method posthog.ai.evaluations.Scorers.create(*, name: str, kind: ScorerKind, config: ScorerConfig, description: str | None | _Omitted = _OMITTED)
+method posthog.ai.evaluations.Scorers.create(*, name: str, kind: ScorerKind, config: ScorerConfig, description: str | None | _Omitted = _OMITTED, tags: Sequence[str] | _Omitted = _OMITTED)
 method posthog.ai.evaluations.Scorers.create_version(scorer_id: str | UUID, *, config: _ConfigT, base_version: int | None = None, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED)
 method posthog.ai.evaluations.Scorers.get(scorer_id: str | UUID)
 method posthog.ai.evaluations.Scorers.get_version(scorer_id: str | UUID, version_id: str | UUID)
-method posthog.ai.evaluations.Scorers.list(*, limit: int = 100, offset: int = 0, search: str | None = None, kind: ScorerKind | None = None, archived: bool | None = None, order_by: ScorerOrder | None = None)
+method posthog.ai.evaluations.Scorers.list(*, limit: int = 100, offset: int = 0, search: str | None = None, kind: ScorerKind | None = None, archived: bool | None = None, order_by: ScorerOrder | None = None, tags: Sequence[str] | None = None, tag_match: Literal['any', 'all'] = 'any')
 method posthog.ai.evaluations.Scorers.list_versions(scorer_id: str | UUID, *, limit: int = 50, cursor: str | None = None)
-method posthog.ai.evaluations.Scorers.update(scorer_id: str | UUID, *, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED, archived: bool | _Omitted = _OMITTED)
+method posthog.ai.evaluations.Scorers.update(scorer_id: str | UUID, *, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED, archived: bool | _Omitted = _OMITTED, tags: Sequence[str] | _Omitted = _OMITTED)
 method posthog.ai.gemini.gemini.Models.embed_content(model: str, contents, posthog_distinct_id: Optional[str] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: Optional[bool] = None, posthog_groups: Optional[Dict[str, Any]] = None, **kwargs: Any)
 method posthog.ai.gemini.gemini.Models.generate_content(model: str, contents, posthog_distinct_id: Optional[str] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: Optional[bool] = None, posthog_groups: Optional[Dict[str, Any]] = None, **kwargs: Any)
 method posthog.ai.gemini.gemini.Models.generate_content_stream(model: str, contents, posthog_distinct_id: Optional[str] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: Optional[bool] = None, posthog_groups: Optional[Dict[str, Any]] = None, **kwargs: Any)

From 81931fa3048df82243d0d63e636a9ceecd1d0148 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 19:19:42 +0000
Subject: [PATCH 048/245] chore: Release v7.73.0 [skip ci]

---
 .sampo/changesets/evaluation-tags.md | 5 -----
 openfeature-provider/CHANGELOG.md    | 6 ++++++
 openfeature-provider/pyproject.toml  | 2 +-
 posthog/CHANGELOG.md                 | 6 ++++++
 posthog/version.py                   | 2 +-
 pyproject.toml                       | 2 +-
 uv.lock                              | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/evaluation-tags.md

diff --git a/.sampo/changesets/evaluation-tags.md b/.sampo/changesets/evaluation-tags.md
deleted file mode 100644
index ea734ed30..000000000
--- a/.sampo/changesets/evaluation-tags.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Support tags in synchronous and asynchronous AI observability scorer creation, metadata updates, responses, and list filters. Add `get_tags()` and `set_tags()` to offline experiment handles for reading, replacing, and clearing experiment tags independently of uploads and completion.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index bc04fd642..a4d699e13 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.109 — 2026-10-19
+
+### Patch changes
+
+- Updated dependencies: posthog@7.73.0
+
 ## 0.1.108 — 2026-10-19
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3b050c912..4c62436e2 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.108"
+version = "0.1.109"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index d86fb82b4..0e79d205b 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.73.0 — 2026-10-19
+
+### Minor changes
+
+- [b086f65](https://github.com/posthog/posthog-python/commit/b086f65437c4904310279646da76321a80294056) Support tags in synchronous and asynchronous AI observability scorer creation, metadata updates, responses, and list filters. Add `get_tags()` and `set_tags()` to offline experiment handles for reading, replacing, and clearing experiment tags independently of uploads and completion. — Thanks @Radu-Raicea!
+
 ## 7.72.0 — 2026-10-19
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 36a0dbd29..d502f0d3c 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.72.0"
+VERSION = "7.73.0"
diff --git a/pyproject.toml b/pyproject.toml
index 2314476ec..5c97f9b73 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.72.0"
+version = "7.73.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 54d071319..92e5cbcc0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2500,7 +2500,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.108"
+version = "0.1.109"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2830,7 +2830,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.72.0"
+version = "7.73.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 9e62e0f9c5a7d6a23a419f93c8f016d43faec2db Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 19 Oct 2026 19:19:47 +0000
Subject: [PATCH 049/245] Update generated references

---
 .../posthog-python-references-7.73.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.73.0.json

diff --git a/references/posthog-python-references-7.73.0.json b/references/posthog-python-references-7.73.0.json
new file mode 100644
index 000000000..9e6844b34
--- /dev/null
+++ b/references/posthog-python-references-7.73.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.73.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 05421adfc..9e6844b34 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.72.0",
+    "version": "7.73.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 20dabaa258b810bae3696bcb67b9679c18ef8f25 Mon Sep 17 00:00:00 2001
From: Sebastian Turner <sebastiant3484@gmail.com>
Date: Mon, 19 Oct 2026 15:18:23 -0700
Subject: [PATCH 050/245] fix(flags): accept rediss:// URLs for
 flag_fallback_cache_url (#1080)

Signed-off-by: Sebastian Turner <sebastiant3484@gmail.com>
---
 .sampo/changesets/flag-cache-rediss-scheme.md |  5 ++++
 posthog/client.py                             |  5 ++--
 posthog/test/test_client.py                   | 27 +++++++++++++++++++
 3 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/flag-cache-rediss-scheme.md

diff --git a/.sampo/changesets/flag-cache-rediss-scheme.md b/.sampo/changesets/flag-cache-rediss-scheme.md
new file mode 100644
index 000000000..92e5490e1
--- /dev/null
+++ b/.sampo/changesets/flag-cache-rediss-scheme.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Accept rediss:// URLs in flag_fallback_cache_url so the flag fallback cache can use Redis over TLS.
diff --git a/posthog/client.py b/posthog/client.py
index 2f33a29ae..1efb521e3 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -4823,6 +4823,7 @@ def _initialize_flag_cache(self, cache_url):
                 - "memory://local/?ttl=300&size=10000": Memory cache with TTL and size
                 - "redis://localhost:6379/0/?ttl=300": Redis cache with TTL
                 - "redis://username:password@host:port/?ttl=300": Redis with auth
+                - "rediss://username:password@host:port/?ttl=300": Redis over TLS
 
         Example usage:
             # Memory cache
@@ -4858,7 +4859,7 @@ def _initialize_flag_cache(self, cache_url):
                 size = int(query_params.get("size", [10000])[0])
                 return FlagCache(size, ttl)
 
-            elif scheme == "redis":
+            elif scheme in ("redis", "rediss"):
                 try:
                     # Not worth importing redis if we're not using it
                     import redis
@@ -4891,7 +4892,7 @@ def _initialize_flag_cache(self, cache_url):
                     return None
             else:
                 raise ValueError(
-                    f"Unknown cache URL scheme: {scheme}. Supported schemes: memory, redis"
+                    f"Unknown cache URL scheme: {scheme}. Supported schemes: memory, redis, rediss"
                 )
 
         except Exception as e:
diff --git a/posthog/test/test_client.py b/posthog/test/test_client.py
index 1c86a0daa..2a1923028 100644
--- a/posthog/test/test_client.py
+++ b/posthog/test/test_client.py
@@ -24,6 +24,7 @@
 from posthog.test.logging_helpers import capture_message_only_logs
 from posthog.test.test_utils import FAKE_TEST_API_KEY
 from posthog.types import FeatureFlag, FeatureFlagResult, LegacyFlagMetadata
+from posthog.utils import RedisFlagCache
 from posthog.version import VERSION
 from posthog.contexts import tag
 
@@ -2589,6 +2590,32 @@ def test_shutdown_clears_feature_flag_called_dedupe_cache(self):
 
         self.assertEqual(len(client.distinct_ids_feature_flags_reported), 0)
 
+    @parameterized.expand(
+        [
+            ("redis://localhost:6379/0/?ttl=120", "redis://localhost:6379/0/"),
+            (
+                "rediss://user:secret@cache.example.com:6380/1?ttl=120",
+                "rediss://user:secret@cache.example.com:6380/1",
+            ),
+        ]
+    )
+    def test_flag_fallback_cache_url_accepts_redis_schemes(
+        self, cache_url, expected_redis_url
+    ):
+        fake_redis = mock.Mock()
+        with mock.patch.dict(sys.modules, {"redis": fake_redis}):
+            client = Client(
+                FAKE_TEST_API_KEY,
+                send=False,
+                thread=0,
+                flag_fallback_cache_url=cache_url,
+            )
+
+        fake_redis.from_url.assert_called_once_with(expected_redis_url)
+        self.assertIsInstance(client.flag_cache, RedisFlagCache)
+        self.assertEqual(client.flag_cache.default_ttl, 120)
+        client.shutdown()
+
     def test_shutdown_flushes_without_timeout(self):
         client = Client(FAKE_TEST_API_KEY, flush_interval=0.01)
 

From 223b592a9666b8c28f6bd90883126ced513d4195 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 11:52:55 +0000
Subject: [PATCH 051/245] chore: Release v7.73.1 [skip ci]

---
 .sampo/changesets/flag-cache-rediss-scheme.md | 5 -----
 openfeature-provider/CHANGELOG.md             | 6 ++++++
 openfeature-provider/pyproject.toml           | 2 +-
 posthog/CHANGELOG.md                          | 6 ++++++
 posthog/version.py                            | 2 +-
 pyproject.toml                                | 2 +-
 uv.lock                                       | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/flag-cache-rediss-scheme.md

diff --git a/.sampo/changesets/flag-cache-rediss-scheme.md b/.sampo/changesets/flag-cache-rediss-scheme.md
deleted file mode 100644
index 92e5490e1..000000000
--- a/.sampo/changesets/flag-cache-rediss-scheme.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Accept rediss:// URLs in flag_fallback_cache_url so the flag fallback cache can use Redis over TLS.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index a4d699e13..8b582d72a 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.110 — 2026-10-20
+
+### Patch changes
+
+- Updated dependencies: posthog@7.73.1
+
 ## 0.1.109 — 2026-10-19
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 4c62436e2..9af61ba49 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.109"
+version = "0.1.110"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 0e79d205b..9629faa88 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.73.1 — 2026-10-20
+
+### Patch changes
+
+- [20dabaa](https://github.com/posthog/posthog-python/commit/20dabaa258b810bae3696bcb67b9679c18ef8f25) Accept rediss:// URLs in flag_fallback_cache_url so the flag fallback cache can use Redis over TLS. — Thanks @auraseb for your first contribution 🎉!
+
 ## 7.73.0 — 2026-10-19
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index d502f0d3c..ab107779f 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.73.0"
+VERSION = "7.73.1"
diff --git a/pyproject.toml b/pyproject.toml
index 5c97f9b73..2c84a22fa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.73.0"
+version = "7.73.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 92e5cbcc0..333b00961 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2500,7 +2500,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.109"
+version = "0.1.110"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2830,7 +2830,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.0"
+version = "7.73.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From e9e0830aece3d22871fca082b6143cc2f0265e5c Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 11:53:01 +0000
Subject: [PATCH 052/245] Update generated references

---
 .../posthog-python-references-7.73.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.73.1.json

diff --git a/references/posthog-python-references-7.73.1.json b/references/posthog-python-references-7.73.1.json
new file mode 100644
index 000000000..9c588f586
--- /dev/null
+++ b/references/posthog-python-references-7.73.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.73.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 9e6844b34..9c588f586 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.73.0",
+    "version": "7.73.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 305dee3ab53afe20482295690dcf3d978a574b67 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 12:15:58 -0400
Subject: [PATCH 053/245] chore(deps): bump aiohttp from 3.14.3 to 3.14.4
 (#1086)

---
updated-dependencies:
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 513 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 303 insertions(+), 210 deletions(-)

diff --git a/uv.lock b/uv.lock
index 333b00961..79fe59973 100644
--- a/uv.lock
+++ b/uv.lock
@@ -67,7 +67,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -80,126 +80,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -4513,101 +4555,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.20.1"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3c/fb/efaa23fa4e45537b827620f04cf8f3cd658b76642205162e072703a5b963/yarl-1.20.1.tar.gz", hash = "sha256:d017a4997ee50c91fd5466cef416231bb82177b93b029906cefc542ce14c35ac", size = 186428, upload-time = "2025-06-10T00:46:09.923Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/65/7fed0d774abf47487c64be14e9223749468922817b5e8792b8a64792a1bb/yarl-1.20.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6032e6da6abd41e4acda34d75a816012717000fa6839f37124a47fcefc49bec4", size = 132910, upload-time = "2025-06-10T00:42:31.108Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/7b/988f55a52da99df9e56dc733b8e4e5a6ae2090081dc2754fc8fd34e60aa0/yarl-1.20.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2c7b34d804b8cf9b214f05015c4fee2ebe7ed05cf581e7192c06555c71f4446a", size = 90644, upload-time = "2025-06-10T00:42:33.851Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/de/30d98f03e95d30c7e3cc093759982d038c8833ec2451001d45ef4854edc1/yarl-1.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0c869f2651cc77465f6cd01d938d91a11d9ea5d798738c1dc077f3de0b5e5fed", size = 89322, upload-time = "2025-06-10T00:42:35.688Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7a/f2f314f5ebfe9200724b0b748de2186b927acb334cf964fd312eb86fc286/yarl-1.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62915e6688eb4d180d93840cda4110995ad50c459bf931b8b3775b37c264af1e", size = 323786, upload-time = "2025-06-10T00:42:37.817Z" },
-    { url = "https://files.pythonhosted.org/packages/15/3f/718d26f189db96d993d14b984ce91de52e76309d0fd1d4296f34039856aa/yarl-1.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:41ebd28167bc6af8abb97fec1a399f412eec5fd61a3ccbe2305a18b84fb4ca73", size = 319627, upload-time = "2025-06-10T00:42:39.937Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/76/8fcfbf5fa2369157b9898962a4a7d96764b287b085b5b3d9ffae69cdefd1/yarl-1.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:21242b4288a6d56f04ea193adde174b7e347ac46ce6bc84989ff7c1b1ecea84e", size = 339149, upload-time = "2025-06-10T00:42:42.627Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/95/d7fc301cc4661785967acc04f54a4a42d5124905e27db27bb578aac49b5c/yarl-1.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bea21cdae6c7eb02ba02a475f37463abfe0a01f5d7200121b03e605d6a0439f8", size = 333327, upload-time = "2025-06-10T00:42:44.842Z" },
-    { url = "https://files.pythonhosted.org/packages/65/94/e21269718349582eee81efc5c1c08ee71c816bfc1585b77d0ec3f58089eb/yarl-1.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f8a891e4a22a89f5dde7862994485e19db246b70bb288d3ce73a34422e55b23", size = 326054, upload-time = "2025-06-10T00:42:47.149Z" },
-    { url = "https://files.pythonhosted.org/packages/32/ae/8616d1f07853704523519f6131d21f092e567c5af93de7e3e94b38d7f065/yarl-1.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dd803820d44c8853a109a34e3660e5a61beae12970da479cf44aa2954019bf70", size = 315035, upload-time = "2025-06-10T00:42:48.852Z" },
-    { url = "https://files.pythonhosted.org/packages/48/aa/0ace06280861ef055855333707db5e49c6e3a08840a7ce62682259d0a6c0/yarl-1.20.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b982fa7f74c80d5c0c7b5b38f908971e513380a10fecea528091405f519b9ebb", size = 338962, upload-time = "2025-06-10T00:42:51.024Z" },
-    { url = "https://files.pythonhosted.org/packages/20/52/1e9d0e6916f45a8fb50e6844f01cb34692455f1acd548606cbda8134cd1e/yarl-1.20.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:33f29ecfe0330c570d997bcf1afd304377f2e48f61447f37e846a6058a4d33b2", size = 335399, upload-time = "2025-06-10T00:42:53.007Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/65/60452df742952c630e82f394cd409de10610481d9043aa14c61bf846b7b1/yarl-1.20.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:835ab2cfc74d5eb4a6a528c57f05688099da41cf4957cf08cad38647e4a83b30", size = 338649, upload-time = "2025-06-10T00:42:54.964Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f5/6cd4ff38dcde57a70f23719a838665ee17079640c77087404c3d34da6727/yarl-1.20.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:46b5e0ccf1943a9a6e766b2c2b8c732c55b34e28be57d8daa2b3c1d1d4009309", size = 358563, upload-time = "2025-06-10T00:42:57.28Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/90/c42eefd79d0d8222cb3227bdd51b640c0c1d0aa33fe4cc86c36eccba77d3/yarl-1.20.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:df47c55f7d74127d1b11251fe6397d84afdde0d53b90bedb46a23c0e534f9d24", size = 357609, upload-time = "2025-06-10T00:42:59.055Z" },
-    { url = "https://files.pythonhosted.org/packages/03/c8/cea6b232cb4617514232e0f8a718153a95b5d82b5290711b201545825532/yarl-1.20.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:76d12524d05841276b0e22573f28d5fbcb67589836772ae9244d90dd7d66aa13", size = 350224, upload-time = "2025-06-10T00:43:01.248Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/a3/eaa0ab9712f1f3d01faf43cf6f1f7210ce4ea4a7e9b28b489a2261ca8db9/yarl-1.20.1-cp310-cp310-win32.whl", hash = "sha256:6c4fbf6b02d70e512d7ade4b1f998f237137f1417ab07ec06358ea04f69134f8", size = 81753, upload-time = "2025-06-10T00:43:03.486Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/34/e4abde70a9256465fe31c88ed02c3f8502b7b5dead693a4f350a06413f28/yarl-1.20.1-cp310-cp310-win_amd64.whl", hash = "sha256:aef6c4d69554d44b7f9d923245f8ad9a707d971e6209d51279196d8e8fe1ae16", size = 86817, upload-time = "2025-06-10T00:43:05.231Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/18/893b50efc2350e47a874c5c2d67e55a0ea5df91186b2a6f5ac52eff887cd/yarl-1.20.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:47ee6188fea634bdfaeb2cc420f5b3b17332e6225ce88149a17c413c77ff269e", size = 133833, upload-time = "2025-06-10T00:43:07.393Z" },
-    { url = "https://files.pythonhosted.org/packages/89/ed/b8773448030e6fc47fa797f099ab9eab151a43a25717f9ac043844ad5ea3/yarl-1.20.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d0f6500f69e8402d513e5eedb77a4e1818691e8f45e6b687147963514d84b44b", size = 91070, upload-time = "2025-06-10T00:43:09.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/e3/409bd17b1e42619bf69f60e4f031ce1ccb29bd7380117a55529e76933464/yarl-1.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7a8900a42fcdaad568de58887c7b2f602962356908eedb7628eaf6021a6e435b", size = 89818, upload-time = "2025-06-10T00:43:11.575Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/77/64d8431a4d77c856eb2d82aa3de2ad6741365245a29b3a9543cd598ed8c5/yarl-1.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bad6d131fda8ef508b36be3ece16d0902e80b88ea7200f030a0f6c11d9e508d4", size = 347003, upload-time = "2025-06-10T00:43:14.088Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/d2/0c7e4def093dcef0bd9fa22d4d24b023788b0a33b8d0088b51aa51e21e99/yarl-1.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:df018d92fe22aaebb679a7f89fe0c0f368ec497e3dda6cb81a567610f04501f1", size = 336537, upload-time = "2025-06-10T00:43:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/f3/fc514f4b2cf02cb59d10cbfe228691d25929ce8f72a38db07d3febc3f706/yarl-1.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f969afbb0a9b63c18d0feecf0db09d164b7a44a053e78a7d05f5df163e43833", size = 362358, upload-time = "2025-06-10T00:43:18.704Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/6d/a313ac8d8391381ff9006ac05f1d4331cee3b1efaa833a53d12253733255/yarl-1.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:812303eb4aa98e302886ccda58d6b099e3576b1b9276161469c25803a8db277d", size = 357362, upload-time = "2025-06-10T00:43:20.888Z" },
-    { url = "https://files.pythonhosted.org/packages/00/70/8f78a95d6935a70263d46caa3dd18e1f223cf2f2ff2037baa01a22bc5b22/yarl-1.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98c4a7d166635147924aa0bf9bfe8d8abad6fffa6102de9c99ea04a1376f91e8", size = 348979, upload-time = "2025-06-10T00:43:23.169Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/05/42773027968968f4f15143553970ee36ead27038d627f457cc44bbbeecf3/yarl-1.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12e768f966538e81e6e7550f9086a6236b16e26cd964cf4df35349970f3551cf", size = 337274, upload-time = "2025-06-10T00:43:27.111Z" },
-    { url = "https://files.pythonhosted.org/packages/05/be/665634aa196954156741ea591d2f946f1b78ceee8bb8f28488bf28c0dd62/yarl-1.20.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe41919b9d899661c5c28a8b4b0acf704510b88f27f0934ac7a7bebdd8938d5e", size = 363294, upload-time = "2025-06-10T00:43:28.96Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/90/73448401d36fa4e210ece5579895731f190d5119c4b66b43b52182e88cd5/yarl-1.20.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:8601bc010d1d7780592f3fc1bdc6c72e2b6466ea34569778422943e1a1f3c389", size = 358169, upload-time = "2025-06-10T00:43:30.701Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/b0/fce922d46dc1eb43c811f1889f7daa6001b27a4005587e94878570300881/yarl-1.20.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:daadbdc1f2a9033a2399c42646fbd46da7992e868a5fe9513860122d7fe7a73f", size = 362776, upload-time = "2025-06-10T00:43:32.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/0d/b172628fce039dae8977fd22caeff3eeebffd52e86060413f5673767c427/yarl-1.20.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:03aa1e041727cb438ca762628109ef1333498b122e4c76dd858d186a37cec845", size = 381341, upload-time = "2025-06-10T00:43:34.543Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/9b/5b886d7671f4580209e855974fe1cecec409aa4a89ea58b8f0560dc529b1/yarl-1.20.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:642980ef5e0fa1de5fa96d905c7e00cb2c47cb468bfcac5a18c58e27dbf8d8d1", size = 379988, upload-time = "2025-06-10T00:43:36.489Z" },
-    { url = "https://files.pythonhosted.org/packages/73/be/75ef5fd0fcd8f083a5d13f78fd3f009528132a1f2a1d7c925c39fa20aa79/yarl-1.20.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:86971e2795584fe8c002356d3b97ef6c61862720eeff03db2a7c86b678d85b3e", size = 371113, upload-time = "2025-06-10T00:43:38.592Z" },
-    { url = "https://files.pythonhosted.org/packages/50/4f/62faab3b479dfdcb741fe9e3f0323e2a7d5cd1ab2edc73221d57ad4834b2/yarl-1.20.1-cp311-cp311-win32.whl", hash = "sha256:597f40615b8d25812f14562699e287f0dcc035d25eb74da72cae043bb884d773", size = 81485, upload-time = "2025-06-10T00:43:41.038Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/09/d9c7942f8f05c32ec72cd5c8e041c8b29b5807328b68b4801ff2511d4d5e/yarl-1.20.1-cp311-cp311-win_amd64.whl", hash = "sha256:26ef53a9e726e61e9cd1cda6b478f17e350fb5800b4bd1cd9fe81c4d91cfeb2e", size = 86686, upload-time = "2025-06-10T00:43:42.692Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/9a/cb7fad7d73c69f296eda6815e4a2c7ed53fc70c2f136479a91c8e5fbdb6d/yarl-1.20.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdcc4cd244e58593a4379fe60fdee5ac0331f8eb70320a24d591a3be197b94a9", size = 133667, upload-time = "2025-06-10T00:43:44.369Z" },
-    { url = "https://files.pythonhosted.org/packages/67/38/688577a1cb1e656e3971fb66a3492501c5a5df56d99722e57c98249e5b8a/yarl-1.20.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b29a2c385a5f5b9c7d9347e5812b6f7ab267193c62d282a540b4fc528c8a9d2a", size = 91025, upload-time = "2025-06-10T00:43:46.295Z" },
-    { url = "https://files.pythonhosted.org/packages/50/ec/72991ae51febeb11a42813fc259f0d4c8e0507f2b74b5514618d8b640365/yarl-1.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1112ae8154186dfe2de4732197f59c05a83dc814849a5ced892b708033f40dc2", size = 89709, upload-time = "2025-06-10T00:43:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/99/da/4d798025490e89426e9f976702e5f9482005c548c579bdae792a4c37769e/yarl-1.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90bbd29c4fe234233f7fa2b9b121fb63c321830e5d05b45153a2ca68f7d310ee", size = 352287, upload-time = "2025-06-10T00:43:49.924Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/26/54a15c6a567aac1c61b18aa0f4b8aa2e285a52d547d1be8bf48abe2b3991/yarl-1.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:680e19c7ce3710ac4cd964e90dad99bf9b5029372ba0c7cbfcd55e54d90ea819", size = 345429, upload-time = "2025-06-10T00:43:51.7Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/95/9dcf2386cb875b234353b93ec43e40219e14900e046bf6ac118f94b1e353/yarl-1.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a979218c1fdb4246a05efc2cc23859d47c89af463a90b99b7c56094daf25a16", size = 365429, upload-time = "2025-06-10T00:43:53.494Z" },
-    { url = "https://files.pythonhosted.org/packages/91/b2/33a8750f6a4bc224242a635f5f2cff6d6ad5ba651f6edcccf721992c21a0/yarl-1.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255b468adf57b4a7b65d8aad5b5138dce6a0752c139965711bdcb81bc370e1b6", size = 363862, upload-time = "2025-06-10T00:43:55.766Z" },
-    { url = "https://files.pythonhosted.org/packages/98/28/3ab7acc5b51f4434b181b0cee8f1f4b77a65919700a355fb3617f9488874/yarl-1.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a97d67108e79cfe22e2b430d80d7571ae57d19f17cda8bb967057ca8a7bf5bfd", size = 355616, upload-time = "2025-06-10T00:43:58.056Z" },
-    { url = "https://files.pythonhosted.org/packages/36/a3/f666894aa947a371724ec7cd2e5daa78ee8a777b21509b4252dd7bd15e29/yarl-1.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8570d998db4ddbfb9a590b185a0a33dbf8aafb831d07a5257b4ec9948df9cb0a", size = 339954, upload-time = "2025-06-10T00:43:59.773Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/81/5f466427e09773c04219d3450d7a1256138a010b6c9f0af2d48565e9ad13/yarl-1.20.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97c75596019baae7c71ccf1d8cc4738bc08134060d0adfcbe5642f778d1dca38", size = 365575, upload-time = "2025-06-10T00:44:02.051Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/e3/e4b0ad8403e97e6c9972dd587388940a032f030ebec196ab81a3b8e94d31/yarl-1.20.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1c48912653e63aef91ff988c5432832692ac5a1d8f0fb8a33091520b5bbe19ef", size = 365061, upload-time = "2025-06-10T00:44:04.196Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/99/b8a142e79eb86c926f9f06452eb13ecb1bb5713bd01dc0038faf5452e544/yarl-1.20.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4c3ae28f3ae1563c50f3d37f064ddb1511ecc1d5584e88c6b7c63cf7702a6d5f", size = 364142, upload-time = "2025-06-10T00:44:06.527Z" },
-    { url = "https://files.pythonhosted.org/packages/34/f2/08ed34a4a506d82a1a3e5bab99ccd930a040f9b6449e9fd050320e45845c/yarl-1.20.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c5e9642f27036283550f5f57dc6156c51084b458570b9d0d96100c8bebb186a8", size = 381894, upload-time = "2025-06-10T00:44:08.379Z" },
-    { url = "https://files.pythonhosted.org/packages/92/f8/9a3fbf0968eac704f681726eff595dce9b49c8a25cd92bf83df209668285/yarl-1.20.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2c26b0c49220d5799f7b22c6838409ee9bc58ee5c95361a4d7831f03cc225b5a", size = 383378, upload-time = "2025-06-10T00:44:10.51Z" },
-    { url = "https://files.pythonhosted.org/packages/af/85/9363f77bdfa1e4d690957cd39d192c4cacd1c58965df0470a4905253b54f/yarl-1.20.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564ab3d517e3d01c408c67f2e5247aad4019dcf1969982aba3974b4093279004", size = 374069, upload-time = "2025-06-10T00:44:12.834Z" },
-    { url = "https://files.pythonhosted.org/packages/35/99/9918c8739ba271dcd935400cff8b32e3cd319eaf02fcd023d5dcd487a7c8/yarl-1.20.1-cp312-cp312-win32.whl", hash = "sha256:daea0d313868da1cf2fac6b2d3a25c6e3a9e879483244be38c8e6a41f1d876a5", size = 81249, upload-time = "2025-06-10T00:44:14.731Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/83/5d9092950565481b413b31a23e75dd3418ff0a277d6e0abf3729d4d1ce25/yarl-1.20.1-cp312-cp312-win_amd64.whl", hash = "sha256:48ea7d7f9be0487339828a4de0360d7ce0efc06524a48e1810f945c45b813698", size = 86710, upload-time = "2025-06-10T00:44:16.716Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/e1/2411b6d7f769a07687acee88a062af5833cf1966b7266f3d8dfb3d3dc7d3/yarl-1.20.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0b5ff0fbb7c9f1b1b5ab53330acbfc5247893069e7716840c8e7d5bb7355038a", size = 131811, upload-time = "2025-06-10T00:44:18.933Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/27/584394e1cb76fb771371770eccad35de400e7b434ce3142c2dd27392c968/yarl-1.20.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:14f326acd845c2b2e2eb38fb1346c94f7f3b01a4f5c788f8144f9b630bfff9a3", size = 90078, upload-time = "2025-06-10T00:44:20.635Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/9a/3246ae92d4049099f52d9b0fe3486e3b500e29b7ea872d0f152966fc209d/yarl-1.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f60e4ad5db23f0b96e49c018596707c3ae89f5d0bd97f0ad3684bcbad899f1e7", size = 88748, upload-time = "2025-06-10T00:44:22.34Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/25/35afe384e31115a1a801fbcf84012d7a066d89035befae7c5d4284df1e03/yarl-1.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:49bdd1b8e00ce57e68ba51916e4bb04461746e794e7c4d4bbc42ba2f18297691", size = 349595, upload-time = "2025-06-10T00:44:24.314Z" },
-    { url = "https://files.pythonhosted.org/packages/28/2d/8aca6cb2cabc8f12efcb82749b9cefecbccfc7b0384e56cd71058ccee433/yarl-1.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:66252d780b45189975abfed839616e8fd2dbacbdc262105ad7742c6ae58f3e31", size = 342616, upload-time = "2025-06-10T00:44:26.167Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/e9/1312633d16b31acf0098d30440ca855e3492d66623dafb8e25b03d00c3da/yarl-1.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59174e7332f5d153d8f7452a102b103e2e74035ad085f404df2e40e663a22b28", size = 361324, upload-time = "2025-06-10T00:44:27.915Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/a0/688cc99463f12f7669eec7c8acc71ef56a1521b99eab7cd3abb75af887b0/yarl-1.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e3968ec7d92a0c0f9ac34d5ecfd03869ec0cab0697c91a45db3fbbd95fe1b653", size = 359676, upload-time = "2025-06-10T00:44:30.041Z" },
-    { url = "https://files.pythonhosted.org/packages/af/44/46407d7f7a56e9a85a4c207724c9f2c545c060380718eea9088f222ba697/yarl-1.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d1a4fbb50e14396ba3d375f68bfe02215d8e7bc3ec49da8341fe3157f59d2ff5", size = 352614, upload-time = "2025-06-10T00:44:32.171Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/91/31163295e82b8d5485d31d9cf7754d973d41915cadce070491778d9c9825/yarl-1.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11a62c839c3a8eac2410e951301309426f368388ff2f33799052787035793b02", size = 336766, upload-time = "2025-06-10T00:44:34.494Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/8e/c41a5bc482121f51c083c4c2bcd16b9e01e1cf8729e380273a952513a21f/yarl-1.20.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:041eaa14f73ff5a8986b4388ac6bb43a77f2ea09bf1913df7a35d4646db69e53", size = 364615, upload-time = "2025-06-10T00:44:36.856Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/5b/61a3b054238d33d70ea06ebba7e58597891b71c699e247df35cc984ab393/yarl-1.20.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:377fae2fef158e8fd9d60b4c8751387b8d1fb121d3d0b8e9b0be07d1b41e83dc", size = 360982, upload-time = "2025-06-10T00:44:39.141Z" },
-    { url = "https://files.pythonhosted.org/packages/df/a3/6a72fb83f8d478cb201d14927bc8040af901811a88e0ff2da7842dd0ed19/yarl-1.20.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1c92f4390e407513f619d49319023664643d3339bd5e5a56a3bebe01bc67ec04", size = 369792, upload-time = "2025-06-10T00:44:40.934Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/af/4cc3c36dfc7c077f8dedb561eb21f69e1e9f2456b91b593882b0b18c19dc/yarl-1.20.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d25ddcf954df1754ab0f86bb696af765c5bfaba39b74095f27eececa049ef9a4", size = 382049, upload-time = "2025-06-10T00:44:42.854Z" },
-    { url = "https://files.pythonhosted.org/packages/19/3a/e54e2c4752160115183a66dc9ee75a153f81f3ab2ba4bf79c3c53b33de34/yarl-1.20.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:909313577e9619dcff8c31a0ea2aa0a2a828341d92673015456b3ae492e7317b", size = 384774, upload-time = "2025-06-10T00:44:45.275Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/20/200ae86dabfca89060ec6447649f219b4cbd94531e425e50d57e5f5ac330/yarl-1.20.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:793fd0580cb9664548c6b83c63b43c477212c0260891ddf86809e1c06c8b08f1", size = 374252, upload-time = "2025-06-10T00:44:47.31Z" },
-    { url = "https://files.pythonhosted.org/packages/83/75/11ee332f2f516b3d094e89448da73d557687f7d137d5a0f48c40ff211487/yarl-1.20.1-cp313-cp313-win32.whl", hash = "sha256:468f6e40285de5a5b3c44981ca3a319a4b208ccc07d526b20b12aeedcfa654b7", size = 81198, upload-time = "2025-06-10T00:44:49.164Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/ba/39b1ecbf51620b40ab402b0fc817f0ff750f6d92712b44689c2c215be89d/yarl-1.20.1-cp313-cp313-win_amd64.whl", hash = "sha256:495b4ef2fea40596bfc0affe3837411d6aa3371abcf31aac0ccc4bdd64d4ef5c", size = 86346, upload-time = "2025-06-10T00:44:51.182Z" },
-    { url = "https://files.pythonhosted.org/packages/43/c7/669c52519dca4c95153c8ad96dd123c79f354a376346b198f438e56ffeb4/yarl-1.20.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f60233b98423aab21d249a30eb27c389c14929f47be8430efa7dbd91493a729d", size = 138826, upload-time = "2025-06-10T00:44:52.883Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/42/fc0053719b44f6ad04a75d7f05e0e9674d45ef62f2d9ad2c1163e5c05827/yarl-1.20.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6f3eff4cc3f03d650d8755c6eefc844edde99d641d0dcf4da3ab27141a5f8ddf", size = 93217, upload-time = "2025-06-10T00:44:54.658Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/7f/fa59c4c27e2a076bba0d959386e26eba77eb52ea4a0aac48e3515c186b4c/yarl-1.20.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:69ff8439d8ba832d6bed88af2c2b3445977eba9a4588b787b32945871c2444e3", size = 92700, upload-time = "2025-06-10T00:44:56.784Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/d4/062b2f48e7c93481e88eff97a6312dca15ea200e959f23e96d8ab898c5b8/yarl-1.20.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cf34efa60eb81dd2645a2e13e00bb98b76c35ab5061a3989c7a70f78c85006d", size = 347644, upload-time = "2025-06-10T00:44:59.071Z" },
-    { url = "https://files.pythonhosted.org/packages/89/47/78b7f40d13c8f62b499cc702fdf69e090455518ae544c00a3bf4afc9fc77/yarl-1.20.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8e0fe9364ad0fddab2688ce72cb7a8e61ea42eff3c7caeeb83874a5d479c896c", size = 323452, upload-time = "2025-06-10T00:45:01.605Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/2b/490d3b2dc66f52987d4ee0d3090a147ea67732ce6b4d61e362c1846d0d32/yarl-1.20.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f64fbf81878ba914562c672024089e3401974a39767747691c65080a67b18c1", size = 346378, upload-time = "2025-06-10T00:45:03.946Z" },
-    { url = "https://files.pythonhosted.org/packages/66/ad/775da9c8a94ce925d1537f939a4f17d782efef1f973039d821cbe4bcc211/yarl-1.20.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6342d643bf9a1de97e512e45e4b9560a043347e779a173250824f8b254bd5ce", size = 353261, upload-time = "2025-06-10T00:45:05.992Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/23/0ed0922b47a4f5c6eb9065d5ff1e459747226ddce5c6a4c111e728c9f701/yarl-1.20.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56dac5f452ed25eef0f6e3c6a066c6ab68971d96a9fb441791cad0efba6140d3", size = 335987, upload-time = "2025-06-10T00:45:08.227Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/49/bc728a7fe7d0e9336e2b78f0958a2d6b288ba89f25a1762407a222bf53c3/yarl-1.20.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7d7f497126d65e2cad8dc5f97d34c27b19199b6414a40cb36b52f41b79014be", size = 329361, upload-time = "2025-06-10T00:45:10.11Z" },
-    { url = "https://files.pythonhosted.org/packages/93/8f/b811b9d1f617c83c907e7082a76e2b92b655400e61730cd61a1f67178393/yarl-1.20.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:67e708dfb8e78d8a19169818eeb5c7a80717562de9051bf2413aca8e3696bf16", size = 346460, upload-time = "2025-06-10T00:45:12.055Z" },
-    { url = "https://files.pythonhosted.org/packages/70/fd/af94f04f275f95da2c3b8b5e1d49e3e79f1ed8b6ceb0f1664cbd902773ff/yarl-1.20.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:595c07bc79af2494365cc96ddeb772f76272364ef7c80fb892ef9d0649586513", size = 334486, upload-time = "2025-06-10T00:45:13.995Z" },
-    { url = "https://files.pythonhosted.org/packages/84/65/04c62e82704e7dd0a9b3f61dbaa8447f8507655fd16c51da0637b39b2910/yarl-1.20.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7bdd2f80f4a7df852ab9ab49484a4dee8030023aa536df41f2d922fd57bf023f", size = 342219, upload-time = "2025-06-10T00:45:16.479Z" },
-    { url = "https://files.pythonhosted.org/packages/91/95/459ca62eb958381b342d94ab9a4b6aec1ddec1f7057c487e926f03c06d30/yarl-1.20.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c03bfebc4ae8d862f853a9757199677ab74ec25424d0ebd68a0027e9c639a390", size = 350693, upload-time = "2025-06-10T00:45:18.399Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/00/d393e82dd955ad20617abc546a8f1aee40534d599ff555ea053d0ec9bf03/yarl-1.20.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:344d1103e9c1523f32a5ed704d576172d2cabed3122ea90b1d4e11fe17c66458", size = 355803, upload-time = "2025-06-10T00:45:20.677Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ed/c5fb04869b99b717985e244fd93029c7a8e8febdfcffa06093e32d7d44e7/yarl-1.20.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:88cab98aa4e13e1ade8c141daeedd300a4603b7132819c484841bb7af3edce9e", size = 341709, upload-time = "2025-06-10T00:45:23.221Z" },
-    { url = "https://files.pythonhosted.org/packages/24/fd/725b8e73ac2a50e78a4534ac43c6addf5c1c2d65380dd48a9169cc6739a9/yarl-1.20.1-cp313-cp313t-win32.whl", hash = "sha256:b121ff6a7cbd4abc28985b6028235491941b9fe8fe226e6fdc539c977ea1739d", size = 86591, upload-time = "2025-06-10T00:45:25.793Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c3/b2e9f38bc3e11191981d57ea08cab2166e74ea770024a646617c9cddd9f6/yarl-1.20.1-cp313-cp313t-win_amd64.whl", hash = "sha256:541d050a355bbbc27e55d906bc91cb6fe42f96c01413dd0f4ed5a5240513874f", size = 93003, upload-time = "2025-06-10T00:45:27.752Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload-time = "2025-06-10T00:46:07.521Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]

From 1b865499fc0e51a44c8a6d32f5a953241444bb45 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 12:16:04 -0400
Subject: [PATCH 054/245] chore(deps): bump the uv group across 7 directories
 with 1 update (#1087)

---
updated-dependencies:
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: aiohttp
  dependency-version: 3.14.4
  dependency-type: indirect
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-crewai/uv.lock          | 554 ++++++++++---------
 examples/example-ai-dspy/uv.lock            | 554 ++++++++++---------
 examples/example-ai-instructor/uv.lock      | 554 ++++++++++---------
 examples/example-ai-litellm/uv.lock         | 556 +++++++++++---------
 examples/example-ai-llamaindex/uv.lock      | 556 +++++++++++---------
 examples/example-ai-pydantic-ai/uv.lock     | 556 +++++++++++---------
 examples/example-ai-semantic-kernel/uv.lock | 556 +++++++++++---------
 7 files changed, 2126 insertions(+), 1760 deletions(-)

diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index 752884d9c..bf5e38a4c 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -24,7 +24,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -37,126 +37,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -4125,142 +4167,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-dspy/uv.lock b/examples/example-ai-dspy/uv.lock
index 164621bcb..80a8f76aa 100644
--- a/examples/example-ai-dspy/uv.lock
+++ b/examples/example-ai-dspy/uv.lock
@@ -21,7 +21,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -34,126 +34,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -2675,142 +2717,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-instructor/uv.lock b/examples/example-ai-instructor/uv.lock
index b813097c3..21bc1548d 100644
--- a/examples/example-ai-instructor/uv.lock
+++ b/examples/example-ai-instructor/uv.lock
@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -30,126 +30,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -1172,7 +1214,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.73.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1196,7 +1238,9 @@ requires-dist = [
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -1704,142 +1748,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-litellm/uv.lock b/examples/example-ai-litellm/uv.lock
index a17bcd98f..15411cad4 100644
--- a/examples/example-ai-litellm/uv.lock
+++ b/examples/example-ai-litellm/uv.lock
@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -30,126 +30,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -1468,11 +1510,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.3"
+version = "1.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/53/ed9d74092561d4b01a2ef1349d52cdbc135e526c245f366b089cfca6de49/python_dotenv-1.2.3.tar.gz", hash = "sha256:a20a594dabeaa385725aa239d5244871c143ecb356add8a20fcf23773a6c3a35", size = 58945, upload-time = "2026-08-16T16:54:54.067Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/26/2fbeedb218a787a5eea551c7532cac4e009f83d689dd2faa0d0353473f86/python_dotenv-1.2.4.tar.gz", hash = "sha256:f0d53e69935a851c0dcc78f3ab7aaccd8cabef0b92382b576b824212902873c0", size = 60824, upload-time = "2026-10-01T05:36:10Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/17/c5c6b53ddc18f297992099b3d9ec16c855c0ccc83263a21fe4d1c625ec6c/python_dotenv-1.2.3-py3-none-any.whl", hash = "sha256:904552145e8bfed22162c09dab1c2b9b54fefa7b23ba780f4f26ca0316b0f0d9", size = 22780, upload-time = "2026-08-16T16:54:52.473Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d1/38f3a3405989a89ac18390803e70c6ad7c7760da4f9b83cbeca0c44a0c72/python_dotenv-1.2.4-py3-none-any.whl", hash = "sha256:42269a8a5b3fd54ffa6f3d84b18abed50064717576b4ecf03dc4a55d8aa04fdc", size = 23266, upload-time = "2026-10-01T05:36:08.633Z" },
 ]
 
 [[package]]
@@ -2001,142 +2043,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index aaba29e51..1a36872ad 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -21,7 +21,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -34,126 +34,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -1763,7 +1805,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.2"
+version = "7.73.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2593,142 +2635,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index 0a303b6ab..cac931f92 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -48,7 +48,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -61,126 +61,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -2066,7 +2108,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.2"
+version = "7.73.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -3731,142 +3773,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-semantic-kernel/uv.lock b/examples/example-ai-semantic-kernel/uv.lock
index 956aa7a39..5f8f0ffc8 100644
--- a/examples/example-ai-semantic-kernel/uv.lock
+++ b/examples/example-ai-semantic-kernel/uv.lock
@@ -25,7 +25,7 @@ wheels = [
 
 [[package]]
 name = "aiohttp"
-version = "3.14.3"
+version = "3.14.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -38,126 +38,168 @@ dependencies = [
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/4d/4a99fb425c5e0cad715eea7bd190aff46f38b959a0a2dadb993705d34b26/aiohttp-3.14.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eb0495d778817619273c108784292be161a924b9f5ae5cbbc70a2caa6838250b", size = 765848, upload-time = "2026-07-23T01:52:08.217Z" },
-    { url = "https://files.pythonhosted.org/packages/74/e8/43b85dc55b8e950dc644babe762add781319ea881b57b33d2cce12017d12/aiohttp-3.14.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c3c200cf9757edd785051dc699c7ecbec22110dbfcb3fefc7a9f9695eda8ea7a", size = 517476, upload-time = "2026-07-23T01:52:10.846Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/9e/73b582c4dbbc3c12ef4473822475effaabf1f934b56f14f5b03fe5d3a2af/aiohttp-3.14.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd51ebf9d3a00c074df4ede271023f4d2dba289bcc740b88191872716014e3c5", size = 515334, upload-time = "2026-07-23T01:52:12.636Z" },
-    { url = "https://files.pythonhosted.org/packages/79/03/e98c3c9e05a5bdf97defe5ff9169baba4f0ec9a901f2d60e0f060c2f051e/aiohttp-3.14.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:134ac5ddcf61c6fad984b9a5727d83492ada43d63471db20fb73042c13fca62f", size = 1708830, upload-time = "2026-07-23T01:52:14.538Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/2c/26e60b694844dfd2176c57f913a22d0cd6a16f9ff202cbda7580d0328b98/aiohttp-3.14.3-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:70c987b27534f9ae1a723f47ae921571d616da21d3208282bf4c52af5164ac43", size = 1674012, upload-time = "2026-07-23T01:52:16.486Z" },
-    { url = "https://files.pythonhosted.org/packages/38/65/672df92e3172cd876aacfa97a952ac560877eb169384b2991ac5b273de4c/aiohttp-3.14.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1b59533861b70a2185c8f4f350f791f39d64358ef6944ce71c5240c9ec0982c9", size = 1767015, upload-time = "2026-07-23T01:52:18.28Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c5/228dec7bfec1c373cc2217cdeb47d6456dcd7a13a4c55144930a75ae3851/aiohttp-3.14.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1c5281acc88b92396f88c7e1e2748f8466689df22b80170e4f51efa712fb47a8", size = 1858700, upload-time = "2026-07-23T01:52:20.08Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/ff/cb36724e8c8d17f90ada567a9ff3efe1d6e9b549fba697a242aece180f21/aiohttp-3.14.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48d67b87db6279c044760787eb01f6413032c2e6f3ba1cafaa492b1c8e578479", size = 1714075, upload-time = "2026-07-23T01:52:22.071Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/3a/296a4135c6366376263aeef54b15caca1f07676c2ae0c525d7832f2f808a/aiohttp-3.14.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f53bcd52f585e1ac3e590d61434eb61f9a88c38df041b4ea126d97144344a77b", size = 1588234, upload-time = "2026-07-23T01:52:23.757Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/81/9d5d853ef892dc066d1eb6db0e87a47348b920c1c879aa554612fdbd9d79/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0fdea2281997af69da84c77ffa6f5938a0285f21fb3887c249d67419ca865b3d", size = 1677300, upload-time = "2026-07-23T01:52:25.861Z" },
-    { url = "https://files.pythonhosted.org/packages/68/96/021d386ae32d9b26d4b88df2e794546232ff56bb6be952bf6be227c0bbc7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cda5fd5c95ad7a125a2e8464acc78b98b94c475a3780d6aa0aa157c93f470f4d", size = 1691501, upload-time = "2026-07-23T01:52:28Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9f/af66adce26a14af135c003cbd0f44ccaa68cebd30ff8ac99ca47fb4958f7/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6debfa7312ff9d4c124dc71d72e9a0a4b9e0879e48ba6fcb42bef5c3300289e2", size = 1735113, upload-time = "2026-07-23T01:52:29.995Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/90/28c390d4c9851effe52ac25b5a2e1d92246acd00728b4fc7975dafb67484/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f4e05329faa0ea1a404b37de4f034fd2c2defcca06a68dc6745e4e56c88e8a48", size = 1577486, upload-time = "2026-07-23T01:52:31.937Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c2/00e23a1bf2abb70dd353f6987db7e7f2491d0261f7363997738c71c98f95/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a3a8296e7ab5c295f53f1041487cb088e1480775aafbf7fe545d93b770a0f96f", size = 1751353, upload-time = "2026-07-23T01:52:33.688Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/7d/d51a706a8cbfa57f0611127daf61ab3ae02ab8420b0407412079227d1c65/aiohttp-3.14.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5373dc80ad1aa2fb9ad95c83f24eef418bbda3a61375f128e5b0192e4f3f9b32", size = 1698681, upload-time = "2026-07-23T01:52:38.167Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/b0/90bd5cd9fdd9787cb4211d284d1fb8401339a933cb0227a15b71e789232f/aiohttp-3.14.3-cp310-cp310-win32.whl", hash = "sha256:a3e22975f905b89a55a488c2a08f2fdb2186175349e917d48985cc468a3d4c6e", size = 456733, upload-time = "2026-07-23T01:52:41.823Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/15/fe5b8f6a71ae112bc677163d0b0701bda5dc15005249582258ede0eb88c7/aiohttp-3.14.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdd0e2834dce1a26c1bbe26464861e16bbe217042cbff619247c11594472518c", size = 480460, upload-time = "2026-07-23T01:52:43.905Z" },
-    { url = "https://files.pythonhosted.org/packages/54/00/45e98b6645cd7f00a4b78b749ebd309094b0eaeb2d2e96157eadbc0d0050/aiohttp-3.14.3-cp310-cp310-win_arm64.whl", hash = "sha256:eac645b09bcfdf73df7536331f0678c1086ea250981118ddb5199e17ccef72bb", size = 453479, upload-time = "2026-07-23T01:52:46.075Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" },
-    { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" },
-    { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" },
-    { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" },
-    { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
-    { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
-    { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
-    { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
-    { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
-    { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
-    { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
-    { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
-    { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
-    { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
-    { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
-    { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
-    { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
-    { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
-    { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
-    { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
-    { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
-    { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
-    { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
-    { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
-    { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
-    { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
-    { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
-    { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
-    { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
-    { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
-    { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
-    { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
-    { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
-    { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
-    { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
-    { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
-    { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
-    { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/93/2f/6a91adaa2dc26877d6ed2f54c0370c8910f019db7d77c5c6a194611e93ea/aiohttp-3.14.4.tar.gz", hash = "sha256:831fc5bd39ec2517851e348f613ddb5447a47cf4b71cb09845af7ad7ed45d8f9", size = 8077839, upload-time = "2026-10-05T17:43:48.309Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/08/290e4be6e3ed239751c446505c324406a4ae8a82a15009a12a3c550f18d9/aiohttp-3.14.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dea3b3653c1d0d6babd8ce09cb9e5a7776864315d9cfb1c569f926389874a261", size = 834853, upload-time = "2026-10-05T17:37:45.079Z" },
+    { url = "https://files.pythonhosted.org/packages/81/81/ed5e04508ba1fcf9a34e0449c78009956e8256f62ebef708e2948594cf94/aiohttp-3.14.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3099a389e5b5900fc79c6f613015ff3f8fa06a519744e6001cc68a31ba418cac", size = 560957, upload-time = "2026-10-05T17:37:47.497Z" },
+    { url = "https://files.pythonhosted.org/packages/90/28/1a91411c53704db0481cc64b0f0c9465aa9d738856abdcaa3a5bbbe18180/aiohttp-3.14.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:70247156fc76e92919f9aacb820556cb30289a54784299a31714d030bb604d84", size = 553475, upload-time = "2026-10-05T17:37:49.099Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/2e/1038f3fa8832f9f4bed0f9f751f70dbc52bc4a09c66788f97bbfb0ce3d88/aiohttp-3.14.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fdf2d2a6ad402797422949f4a200a60d43e3a021695c8a7804aa1d5bbef22652", size = 1845211, upload-time = "2026-10-05T17:37:50.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/54/e2253f17604c5c1c69a05e3c12400b51cd6a5fb32d7175592114d8c7a470/aiohttp-3.14.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ba835fad8d4b5eaea0d34f9461cf499737a720a5f8bc6768d2f6d98a1d3ba8b5", size = 1814629, upload-time = "2026-10-05T17:37:52.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ef/7bd1e45db925376720555d7268c2d642b113105263d37a522e41e1ba3a6c/aiohttp-3.14.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d4415ca5c9c8b24bc2f5733f870d4eab4929e680203559ba60131dd1a27852a", size = 1898528, upload-time = "2026-10-05T17:37:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/26d09668e7e0cadc16027566765aa4ce26e8a41276bad6764848c8b04d11/aiohttp-3.14.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6757e02c2c2b0d7985f57be87cf4a7c5b35708f849e1feaea3f77656ddb9dff", size = 2024385, upload-time = "2026-10-05T17:37:55.626Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/0f1c4aab1cc9518e1bf874e2481e59e541b3e32330b9542e52bb2712f86f/aiohttp-3.14.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a950bd8418ef54eccf5f9f517f08e37c1adab4bc50a470a0422ee1cc1032e29", size = 1859130, upload-time = "2026-10-05T17:37:57.342Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/98/09d5998ba4b5fe9f0cb97d794fab9d1b3d8245c5ec6a5fb84e41a8cec142/aiohttp-3.14.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34cf6f2fe4fc1d7183e8cc0d8c48bbdda828a740bc372d8278126149714d343c", size = 1714768, upload-time = "2026-10-05T17:37:58.831Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/63/39d01a74d525d6443084d47ad4aa8c719f44a030149d03566f3761527465/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bc0fbe4f79c3b156d754dd062718ffe404c3b31ca878d9d2b88ecdbc72ef8369", size = 1813228, upload-time = "2026-10-05T17:38:00.611Z" },
+    { url = "https://files.pythonhosted.org/packages/39/6b/183d7b969bdb7892e86af74147b4afedbb4e03b8cad5006e41aa2034c288/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d3d50a5a07a2b31a4369b86dd4a3acf3c2577c45091dbd5e884b198dec56480b", size = 1831844, upload-time = "2026-10-05T17:38:02.272Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/be/4c6df02b62083efd3f008974cf9016a4afd2023f5a9d2c3fd55499fcbac6/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:de15c46a63f46da881d219e44a04778c40114c756e5575b5ea38143b20eb3713", size = 1868738, upload-time = "2026-10-05T17:38:03.831Z" },
+    { url = "https://files.pythonhosted.org/packages/86/21/406be8b0cf1105a35a6a6da16a95796be39b354e29bfca0d1626d822835f/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:caa4c0fc9b25e8c679baac68337e9c00deb6baf6601fe6f07e8511469cc1ceba", size = 1700006, upload-time = "2026-10-05T17:38:05.631Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/e6/beac98020ea0885ea1ee3b2ef59ec952405590fe2ccef2fa4ef7614c3c2b/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3647f8c090632c70abb1e80826e4ee24faea3f895f0283b60e91a0b17aea5e34", size = 1889997, upload-time = "2026-10-05T17:38:07.578Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/89/d608dd9571988a529c7fead5bc79ad36b56fd52bad7941f40774acbc87e9/aiohttp-3.14.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3f3e8030169843fb652a60a3d32c206e03f260198aa398985a48b41cd7e42f0a", size = 1844619, upload-time = "2026-10-05T17:38:10.003Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7d/7f51e6338d2c74b75173ee66fcb50d778d5407c32f34e76ef1c4b25d0d75/aiohttp-3.14.4-cp310-cp310-win32.whl", hash = "sha256:a1205cbdddfca1428129bb6d23e0b292b09e681df951fa828145d83a63ffc0ca", size = 489598, upload-time = "2026-10-05T17:38:11.795Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2a/3434e450a4395fc07f3070d6ac24553f0b170b173e949216b1723395028c/aiohttp-3.14.4-cp310-cp310-win_amd64.whl", hash = "sha256:e90980e0454a043f81b435309a089ac5deab883779557eb58d004f33990f61e4", size = 512204, upload-time = "2026-10-05T17:38:13.309Z" },
+    { url = "https://files.pythonhosted.org/packages/53/c0/1d89303cf1bea5418268c1cb82b872661bad027e5fd785c2d30d0a31ee6f/aiohttp-3.14.4-cp310-cp310-win_arm64.whl", hash = "sha256:e63eecf9a4b670a24055d5c0486128af16f83b02d9817abd685d3238940f8752", size = 492725, upload-time = "2026-10-05T17:38:14.825Z" },
+    { url = "https://files.pythonhosted.org/packages/81/e3/998dc75634ecd2a24f33bab480b57313059d55bcadff8825a46b7c80a8af/aiohttp-3.14.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb0093ca0817019d539f0d27bdf98e823944e05bb7efd9d2337a45b92e4d1b06", size = 832892, upload-time = "2026-10-05T17:38:16.373Z" },
+    { url = "https://files.pythonhosted.org/packages/58/c9/9bacc26397854440d169f70ae00ea51721f504611d3a64cf043643792c32/aiohttp-3.14.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f482dc9c8309801b4259dd218609d3dae0a7bcdedeac56d90500eabaa0c23465", size = 559893, upload-time = "2026-10-05T17:38:18.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/90c5856014328a8b1e9a753de794edea282182b776ff65f0602ad4ffa520/aiohttp-3.14.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa800bb7c1d00e166493931f2ddacb982db913292503dc2f4884db1f2bc5f105", size = 552850, upload-time = "2026-10-05T17:38:20.385Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/88/e71c29ce6daa78fcee0feb1992f0fdc408f09f42c3311b1f1c68c36f16ea/aiohttp-3.14.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d90e4dae71b26597f6d1fd12af7d092ae67551edf0e524b73e0687214b79ee33", size = 1928941, upload-time = "2026-10-05T17:38:22.218Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/4f/f0f3bebfa521a2ce5fd4302c937701cbc50cd6d908beaa597388639b0b98/aiohttp-3.14.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b681054b8c3b86aa6a0384b6ad7f5cb78dccbabab1f4a3a6793f98ad1378959", size = 1882092, upload-time = "2026-10-05T17:38:24.016Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/0d/5df041fd25dceb4f4cafbbee49bb2c1e2d54a91aedecaf03b77cbb404c44/aiohttp-3.14.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dfe80b41bcf8d80d2125fb99a171adeb86db2fcb35c1a68e0226acba0ba7f03", size = 1986051, upload-time = "2026-10-05T17:38:26.022Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/07/e95eddafffef7c3a74446f67ac4e477a49cec2c78f2ab6c86d1acfd90d2d/aiohttp-3.14.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:71e4a59c6a8c5a6ae8b0b696c32635913e8f526cc01448762eaf5a3c59df8a4f", size = 2107840, upload-time = "2026-10-05T17:38:28.112Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6c/1f83990fea249dcb10f48086726953546efc9199c96b6be7114532ac361f/aiohttp-3.14.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f887c3b7fb3058fc1ccd917f52078540c18d938d12018cb9edd64b6811d20c57", size = 1930721, upload-time = "2026-10-05T17:38:30.046Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d1/48184a186ea26df4f81dd466144dcab7f9cdd1e131bfee0f0e41278c6f0d/aiohttp-3.14.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0da4525e9ba145a11617d2cd7e44fe1acaf471f9c72a0cad28e72879c1020fbb", size = 1774508, upload-time = "2026-10-05T17:38:31.8Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/a9ec758c6d3850453838c31b56d1e4499eb47c80883753a12dcb203f9afa/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f7e8d3c5caa44fdbee3eba1aa1417aa58c74c95d4089fe3c451911117fcbb2f3", size = 1902311, upload-time = "2026-10-05T17:38:33.791Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/49/9a2be54900f2dea6e63bbf9628fced604686a2e301130ccde0b1aa2e7e53/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:09092cf906c18c824b6b16881da5a89cc9cfa9b15344e496bcf880e9045bee33", size = 1912107, upload-time = "2026-10-05T17:38:35.614Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/151254abfc0fe5cbb8e6c41ad04d52122db0af176fb31dbf3bc44e081bda/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:dfd144837e92264878bba6d3a7ffa8206668b21e87748740afd45d193e48c87e", size = 1960207, upload-time = "2026-10-05T17:38:37.322Z" },
+    { url = "https://files.pythonhosted.org/packages/23/99/92c8dce336ac5784755a3144623528516f2e3b6b4871d02cad5a0642ae66/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9413cffe4e0d654b9b524f9c99dde8cbdb37e0ed9a2c4edd2e63adbac6b374e8", size = 1760168, upload-time = "2026-10-05T17:38:39.214Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/f05fd8d1a9595730db8d522882eea76429b9be2ed5337609f7c6e3d9d49c/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f50d719f97ba488dfb8e306cf8c8cc172ff0683ec0af53917b288229aa555ba5", size = 1979946, upload-time = "2026-10-05T17:38:40.927Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/8941aa73ffceabc2a0eb26878b4f1b2958fb7b5358f97cc49b1c00ed9258/aiohttp-3.14.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:68ed4824d96b7afec1f3a8d7fba190fe282718041c5772e20298003e1e3e5d66", size = 1923375, upload-time = "2026-10-05T17:38:43.184Z" },
+    { url = "https://files.pythonhosted.org/packages/18/b5/ef275b63c8bfe0a21e7e8d3ef0e67c4745ed403f1894fe5205057cedd3b9/aiohttp-3.14.4-cp311-cp311-win32.whl", hash = "sha256:d7a41d1427136828e6b11d3f3fd194d4357d5205a5b610be7ae07b1ba52ab974", size = 488414, upload-time = "2026-10-05T17:38:44.978Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/0b/21bdd70a1e072222d9dbd96bed4fbed26f7c46c5a20af11b78d32fd049d6/aiohttp-3.14.4-cp311-cp311-win_amd64.whl", hash = "sha256:2efbdb87e79d596325c4eefaef0f4495d701145e882351310ebc538e854dc7a3", size = 512755, upload-time = "2026-10-05T17:38:47.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/4c/bb324a7d20a9598187bb028ca8d6bcf66c63589c8632420919dd576964ed/aiohttp-3.14.4-cp311-cp311-win_arm64.whl", hash = "sha256:ac6e6f90d9360e460c873f945f11dc8698db0a71fec6612823f1aaaab2c11faa", size = 492960, upload-time = "2026-10-05T17:38:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/22/02/db5935d45347fa8ede56b777930740fb0e72bbb4473ddb6ff8541f6f2afa/aiohttp-3.14.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:55b0b335982b0db7117dff7f6a8e3aad43c4105f9e392ca04f9fc8d958a95cce", size = 817689, upload-time = "2026-10-05T17:38:50.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/56/f00aa46127e6342f019d567853eeeb932e04fb9b9424b5fb981ad68f4178/aiohttp-3.14.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d0d8e435582b0d53009dac99e26a3d2be932ed7c9dbfcfc70f3fce1cf943bd5", size = 549599, upload-time = "2026-10-05T17:38:52.525Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/bc/825c09b09962253a2103e4a88c04374ee939c0c8ea31c270daa0308efb07/aiohttp-3.14.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf734016932d68e1324cfb638cac7a0866a83933a33badf15e836a7e24efb8c0", size = 548132, upload-time = "2026-10-05T17:38:54.629Z" },
+    { url = "https://files.pythonhosted.org/packages/40/80/8a1bc8036540fe7cb38219cc5c0aa67d32e9068165725e8199ea8200b08b/aiohttp-3.14.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:322e3d741b3133bcbb981a41d4f9b8ac3545c18de49c662c2b1f4e1c770b98ad", size = 1898485, upload-time = "2026-10-05T17:38:56.439Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fe/65b464d8520ace0d65b4ca69bc9abe175f842c8ce8d1522d363d9669903f/aiohttp-3.14.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15a3bb5f90a4e515071f3617a45dfe26560beb834a6b6e108cdf4bc9e9719ec3", size = 1875334, upload-time = "2026-10-05T17:38:58.536Z" },
+    { url = "https://files.pythonhosted.org/packages/be/51/9c583be502720e927560a8414f4dfb7c7de41945e1a30ccf7003b93c6f85/aiohttp-3.14.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c044e52df1a466af82cad3518c92ea80cc4ddcfea86966ff083bb34bab29bf4", size = 1937772, upload-time = "2026-10-05T17:39:00.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/3d/b56512df7ea9cbb5f59099a6b375088dd578356a5a3fb27198ab82e19832/aiohttp-3.14.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d613d7d51bf06fe9a5e3aab86ce06d835bb0ceb1a31ea9e8766df4a403ae62a6", size = 2066220, upload-time = "2026-10-05T17:39:02.54Z" },
+    { url = "https://files.pythonhosted.org/packages/11/6c/a7a42701d9ea319140a3d44a24ec72a00b0b46d1b899b26d8a705e65bdd8/aiohttp-3.14.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5e93ab6e6330dce40f5b43996f1fc5f2543296d263a5e4b59ff09e73870b7d8", size = 1922895, upload-time = "2026-10-05T17:39:04.638Z" },
+    { url = "https://files.pythonhosted.org/packages/77/04/f8337bd824ca3fe3968d34dc5037ace1c4872551c4621f8266239311d301/aiohttp-3.14.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20134dc8e68c67e7478124d516449428684c0545b2d3faa575691c8bcbd56678", size = 1712589, upload-time = "2026-10-05T17:39:06.671Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/a6/d20e2c940b592d7c4a21690889dbff64fe0ca3facd9190696368694e1488/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f0daef5ef012369dddc391c61f604111424aa9a96313a69fb899018b09d1b01e", size = 1862251, upload-time = "2026-10-05T17:39:08.523Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e4/d50edd5ae5d024b380a8e892e333840bb22967a9eb9c8492108a403f678a/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:19290a108de0718b73bc69b86e788975c6a59855c671ebe2a98a07a6f968328f", size = 1895155, upload-time = "2026-10-05T17:39:10.305Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/d3/f36f2931f807ccf8437ec15e8f8bfaa4748d4792639401cc767a866abaa0/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1494877625baeffab669f4a25a09ec4eea721b49e35363081a2a8e4231fe141f", size = 1906623, upload-time = "2026-10-05T17:39:12.411Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/0a/94821b711493142bf5e11c27b0d7502776778f7792c77ecc6647357d20c1/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a779ce4bf099ce4ad2cdfed62f1ca536d435f53237c54ff40172fddada24d1b5", size = 1698932, upload-time = "2026-10-05T17:39:14.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/3d5a0d28362f0053c1c457024749911932481e8fd105fddf8305b1f93c81/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b4cec9fca876e2d4f4c6cb32b177390132d04618867689f43fefabf3f5c3980", size = 1934528, upload-time = "2026-10-05T17:39:16.354Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/51/9784a21dc05d2e0f6acaf864f16db53dab0fbd7b0753cef168601eacb012/aiohttp-3.14.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:217707313e23aedde9bea67cf8365c7b138b549ae179121ef3f476cf67e3173a", size = 1901984, upload-time = "2026-10-05T17:39:18.299Z" },
+    { url = "https://files.pythonhosted.org/packages/44/4f/f98c88703e6d620243aa08473a946ca4e3756b6288690e38f0d9f9c1d007/aiohttp-3.14.4-cp312-cp312-win32.whl", hash = "sha256:18a9fb9a3f6e6e63f4d27f9adeef313a2d3c69a84d31170a844623824e722534", size = 480278, upload-time = "2026-10-05T17:39:20.206Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/bc/8555013f84b53e4fdde423131b641af50e822c6d7d9118b24c52b31f6900/aiohttp-3.14.4-cp312-cp312-win_amd64.whl", hash = "sha256:69dcb02d33dfe415d5ee342cc63b7d320efcaf4b761701c7bd7bfb91c715481a", size = 506317, upload-time = "2026-10-05T17:39:22.706Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/ca5bad7bfdaa7ddca053a044a1c7c0d4f3ad9d1f12f96dcab10bfb9c50e7/aiohttp-3.14.4-cp312-cp312-win_arm64.whl", hash = "sha256:d36b0263e7c2fbf1750b9f35d4e7e48b0442d8c45e4a89e3e74168821fb014bb", size = 487683, upload-time = "2026-10-05T17:39:24.482Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ec/7fee140da700ec3f5aa5e0fd2319f67be5e86de197e2384d27e5e6209e0e/aiohttp-3.14.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:264b5a7568306590c44ae4a0237ad1715e35d447ea44ebf324e4c8fd9f78f67a", size = 539114, upload-time = "2026-10-05T17:39:26.322Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/04/930c01ce9e186e787046433d7dc5b45b188885f8406c14b58435b4431974/aiohttp-3.14.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:17e5d7c7775d8dd8e894c7ef6ebfa26509de36868a9a6c7c4fcfaf6a1bf43d60", size = 553514, upload-time = "2026-10-05T17:39:28.104Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d7/983e3cea81c07e95f35d34da4d1e182b5c05489c49b7560b198a83f0da79/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e91dc8fe9cbd052d16f7f1267e285cf8bbac4d2194bd5741f05ef201c77ed09e", size = 521381, upload-time = "2026-10-05T17:39:30.419Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/80baed11659093883f51245755105557d3253e45bd0b693d70df0059d68b/aiohttp-3.14.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8df6157d31703972aec9e3b93963f039ff06318301e30b007c3e941ff8a7ac42", size = 528347, upload-time = "2026-10-05T17:39:32.344Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/18/bfda255c311096c08dab26dc65f3d219f090df37dc5f5f6345f8c3aefc1f/aiohttp-3.14.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:220912b351549dc736c59d104dc443fa615753102bb778a4e98f86e4d94bff6a", size = 539914, upload-time = "2026-10-05T17:39:34.265Z" },
+    { url = "https://files.pythonhosted.org/packages/51/fc/3b6ca6117c0c42481d719411fff7b5d3970ebd906543d3dc1ba40fe2462f/aiohttp-3.14.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2efa42b39bb3f524d5eca3760639b584afdd1143a6b047fda29910ffb75e4993", size = 813997, upload-time = "2026-10-05T17:39:36.061Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f6/86e3e02a9712aadc1ae0a1076bb2d1adf3d9addfe5542a28190c8f9b6d9b/aiohttp-3.14.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7e7356059c8262d2c1fd95242e2b7b70fbc6eee3135bf470049cbec3e968b5b0", size = 548058, upload-time = "2026-10-05T17:39:38.109Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7e/6b9c2e271419d40ca76589613b3c7ab185fd3050a407bd2565b6aa46f695/aiohttp-3.14.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fac247d0cc956d732df1211ac2d8a9999ec8dc1a92a90401de9d52e4ead546f7", size = 545933, upload-time = "2026-10-05T17:39:40.193Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fc/33d6e24a5f8ac32423230088c415e2a1c6efee23d902b62f20506631e40b/aiohttp-3.14.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2eb0f8b03b4f2bd154ed8cf7c1a119a1ad04808c258bf58f90138c83b8c6d5", size = 1888265, upload-time = "2026-10-05T17:39:42.182Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/2eca1d468d83a514621d1280f9992d08649191db2028c9236b4edfa7c723/aiohttp-3.14.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7fbe827d27e0e369fd7bb88ceeaa5b46ea006e73e015b9dd77e3723a53162293", size = 1872300, upload-time = "2026-10-05T17:39:44.195Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f6/5872983de71b0214acdfb86822f5cca295b39be4832ec589fa224aee0f6c/aiohttp-3.14.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a70387146d03af9f047c629b71aa27d9594b3b31ec4c9c91e1a73d0d8bf38e0e", size = 1926213, upload-time = "2026-10-05T17:39:46.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/65/ebfefa11a546c33c717af63c67868408ecf0b33b23a9d75669af95485407/aiohttp-3.14.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d0934926fc65744e2fdd44ce68b2d79d5ee608a1e23f0596b35dd696519bb7c", size = 2056609, upload-time = "2026-10-05T17:39:48.221Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c0/70667e82ec041f4122a17afce711bbcf94a71bec5888b69a49aed8817be2/aiohttp-3.14.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ff4b366510c733974adb7a4102c094e4a6308e6f369315a4cf14d2d0a619cf82", size = 1914740, upload-time = "2026-10-05T17:39:50.304Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/86/559e9dfea676206b20737d7ccb5b3716bff5e58d2a8d53682e5301724cd1/aiohttp-3.14.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:85fac7c99e0ac3dcbd6ae1c33774e0603bfc732ddb967a6fce4a731103c1888e", size = 1703390, upload-time = "2026-10-05T17:39:52.385Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/91/c98897d4cf23e120b2f3980042835cb34c86bbe3c653f3eaacf4bf986349/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef1e9c3b4a2300023a5dc865889ce532cfaf6798ba4ef78fbbefe738a9d23efa", size = 1852642, upload-time = "2026-10-05T17:39:54.391Z" },
+    { url = "https://files.pythonhosted.org/packages/14/13/0258f352cb2c236f358a5b57d138e15fa2566e17accc0758d968dbf2ceb6/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:97e65916588be0f952b3307aaa8460c0771fa98dbea2dd27dabc9f5d84d53c3b", size = 1890616, upload-time = "2026-10-05T17:39:56.466Z" },
+    { url = "https://files.pythonhosted.org/packages/64/3c/f43e294ce1a06d1234a97bd862c1aa31acfa1a0eea3786c22fd0dc1ea731/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:840775cb39a9424f9edf142133a1192263ac5bd79117ad2a16602cef6a0c1e9d", size = 1896638, upload-time = "2026-10-05T17:39:58.585Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/f7/ce1e3a85b73d05037d729d3d32da7d6959b9e433435e9abd46c2fb38410f/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:54f9256430ca040d58affbd551513de13a5cff7d065204fc52b9a1b0af09a049", size = 1693003, upload-time = "2026-10-05T17:40:00.698Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/45eb900d6a9ee046728f5589f3d07f5d78f049b5fb84f48881fa4174d5df/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:6112d5931bf12c776188cab81b82bbb17d86e2e1381f2ade6edc43e6b240f0cb", size = 1927730, upload-time = "2026-10-05T17:40:02.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/43/a83ff79dc8375953a1f00b808a21c82590f4e68304fecccdcc42a25fb7d8/aiohttp-3.14.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:facc6df39047c4732cbd885bb62e40df20885fcd709fc399e11f81b45ce0fff9", size = 1891177, upload-time = "2026-10-05T17:40:04.989Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/ba/fbdc41608d4e2fb6084d960a41b392fa82beb5b126c2466de549b5c67fc8/aiohttp-3.14.4-cp313-cp313-win32.whl", hash = "sha256:7968634fa3a967a2bc0b9aeba1d5a1955501dcd7d0de44b96f7ebfb662797735", size = 479943, upload-time = "2026-10-05T17:40:07.402Z" },
+    { url = "https://files.pythonhosted.org/packages/35/51/d75629750e705832fd5cd52516a82943ed58b6e09c30e14830f5d87452fa/aiohttp-3.14.4-cp313-cp313-win_amd64.whl", hash = "sha256:c0a894b0265d139cd4c2c8bd4643822cc289a4a5331e21e810881bd000ffb2dc", size = 506209, upload-time = "2026-10-05T17:40:09.49Z" },
+    { url = "https://files.pythonhosted.org/packages/02/64/66452d2ffcc13e5e5ee4ba4a968656fa4a98c29ed5ff0205d4fde02b2943/aiohttp-3.14.4-cp313-cp313-win_arm64.whl", hash = "sha256:da16c3037178e72589d91de59536d271dffc92c2be2b47c38a45538cba54fd29", size = 487163, upload-time = "2026-10-05T17:40:11.526Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fd/b653b1f969e2e949fe4726af7a8043e8ef117f202bed7757ac8564e077a1/aiohttp-3.14.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:749bfc43bb1df71bbe6ed215044d5412d786698fc5771d2037436ca49622f3c9", size = 540738, upload-time = "2026-10-05T17:40:14.109Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b5/eea49a0bb697deffac5165d707ec53a24748d6720b3af77a544107b49573/aiohttp-3.14.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:c113e4b489d711f606ca278cd8dc89179746244ea841aa0638b1b134600afad0", size = 554494, upload-time = "2026-10-05T17:40:16.231Z" },
+    { url = "https://files.pythonhosted.org/packages/11/ea/cf8f4efbbfa8572d9965cd43b3c6c84c581aa006772e5ce3ab4020027e9b/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:50969522bc7022026a2c7968e67da5c789f6b716b988edac55dc630390efd5df", size = 522653, upload-time = "2026-10-05T17:40:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/24/9f6721f0b52323789cb1041ffc3afa729462d9925607e733a065b6fc5e17/aiohttp-3.14.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:cbf92cd7a1c800cee244558dd5630abb45c1c1093ef7b0d546a99f526ff7a9eb", size = 529697, upload-time = "2026-10-05T17:40:21.296Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a4/399debc3c2ca0ab88a08e3082b4c4f62d0f66978af60243c63f2345ef337/aiohttp-3.14.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:fc76be08ff407fba717a769aff04ca1b4bf9ecfdcb5caadef84a563fdbbd146d", size = 540526, upload-time = "2026-10-05T17:40:23.548Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/97/90379813b18b795bccdeb3a5a85e9b93ac2c69f9c2a5d0faba59da3ad6d1/aiohttp-3.14.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9b416f995b68a921069e6ec61fa07f2ac3ff033d92e97a69f673af89f5bb954d", size = 818866, upload-time = "2026-10-05T17:40:25.842Z" },
+    { url = "https://files.pythonhosted.org/packages/78/70/824fd0dac819652f1df895b3f621a75bf0a3050c30e38d8d2316e34ab821/aiohttp-3.14.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2c9585101cfca10e74a07cc0ef2bdc6d90616e6750926b20456f429d0608f740", size = 549666, upload-time = "2026-10-05T17:40:28.523Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/eafb2dd200dd2b770ed25a2dc5731c4ba5d58ab3fa8e2e82494bb946808e/aiohttp-3.14.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3c4dcf611b095e7983421f49d01ffbed7ed574891533d606ea115fc23e7c4e90", size = 548961, upload-time = "2026-10-05T17:40:30.613Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/6c733a1c71300293471ac7ef1dffd12b5b4dc9a43c53461224b2b8a7f667/aiohttp-3.14.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8f61a9b5fa56c58e3441f9dc64137f786232d40fb89127190d0e0f84e1e5865", size = 1883165, upload-time = "2026-10-05T17:40:33.062Z" },
+    { url = "https://files.pythonhosted.org/packages/37/34/885ddbd351679a31141b25e0d1a5e4f67738806e564c858b399709b61239/aiohttp-3.14.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d43e538dfc85b705fd832620d050970ef5613b3869a7169b44a554b9dab9eee9", size = 1844119, upload-time = "2026-10-05T17:40:35.266Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/ef/0a64dac53c11d569851efb3e7eddb43551df72b2c172ebb34cccc93bcd3f/aiohttp-3.14.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4135c4bb4b7682a7633fadc7170ea969d843f83aa7224e70111a20675105c985", size = 1930222, upload-time = "2026-10-05T17:40:37.527Z" },
+    { url = "https://files.pythonhosted.org/packages/69/5f/774792ed8f973e0d234fcb06b0f0bc9f29e9a0a0dd847f6418c2904be7d9/aiohttp-3.14.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9055324f156a94fdf6dc9a825ae60f9a2947b88f591ea81ee80826633de62ae7", size = 2038842, upload-time = "2026-10-05T17:40:39.815Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/05/e00f35581c97656d9e864edaa03292382c620dd1d9c836a4f73a2279acc4/aiohttp-3.14.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb22c8e4b60385a9b414c70c6e8b2d0f4b23ff7fc4bb572ceb58297b228169f1", size = 1887845, upload-time = "2026-10-05T17:40:42.359Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/2e/07e3eff5b4c1b082a2eaf0ffb508b409b21ea1ddc9fdc57f3eabb51469a1/aiohttp-3.14.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3b6945559a260112742ed58cde2165488d2fc51aeea34afbaa99d9371b43e1b5", size = 1702533, upload-time = "2026-10-05T17:40:44.569Z" },
+    { url = "https://files.pythonhosted.org/packages/75/44/816844b7f876e6f8fee4ecb088269fcd92241da712e4814a4d624eda13a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f4078a90b174f15efb2c8725e8720c40dbd3b2cf6350dbc085c964a938d9de7", size = 1849058, upload-time = "2026-10-05T17:40:47.818Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/bd/163242e12464a1f3e58a77e28beca949652ddce84abdd5500a91c70a1e0d/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f433c5654e32f72de3ef074d715eb5c7604eb6d28a5c2f3c9e5056f20fe6b306", size = 1854600, upload-time = "2026-10-05T17:40:50.401Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/59/5c1ae708a89524eddfd9c727b87cae26b5c50c3c76683b910ac06151ead0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:871035fe79c636b6bc126ed78df37d72b830dfc751612cb4b1040360edf2719f", size = 1896565, upload-time = "2026-10-05T17:40:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/95300a7de69241fe47d3f838f3fb582c712782e172d447ff650a013ea673/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2617132524f66338f6c1d218cd16081576aefc40df4f2bcba338a99fbf67fec1", size = 1693092, upload-time = "2026-10-05T17:40:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/33/01a8e61d48d0094121092c74125df14c0f8f10ee3149bfe68b6f869409a9/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d8bc326133272deee8ef337581550450e4bb735c0520be893b950a1f5baaf41a", size = 1917073, upload-time = "2026-10-05T17:40:57.656Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d6/1a4f24624cda6686d5b927e26d5d1ae3ebb692faf88e93017fab4b391fd0/aiohttp-3.14.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3ec57223e261b7fa9979c12dbce009ca53439be76cac3af27f860d3e4b1d6f7a", size = 1872656, upload-time = "2026-10-05T17:41:00.123Z" },
+    { url = "https://files.pythonhosted.org/packages/be/be/ed286fcfa2d22061ae021b568c790123505cd482df35e23023339ecaed96/aiohttp-3.14.4-cp314-cp314-win32.whl", hash = "sha256:7242043e71fc449a19a47d92f4e9fd1e0ae8d3f88488982381f422bf6d651218", size = 485461, upload-time = "2026-10-05T17:41:02.686Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/74/e040e6f65f4da305777f1adb3023d47401693489e4a337c983b52d2a0a6b/aiohttp-3.14.4-cp314-cp314-win_amd64.whl", hash = "sha256:019587c7b3a44917dd61bcb312fd5c034f341dc9851b83e7b41b65e08b68ca0f", size = 512147, upload-time = "2026-10-05T17:41:04.98Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/bddb33ae15fdd5a68a10a986587aa9916c418a712fdd110d3b3ae9b51407/aiohttp-3.14.4-cp314-cp314-win_arm64.whl", hash = "sha256:60dc71d38db0988f37e78f6ad4a010a2f6355cfac3fff5f130cf5ef2231f3f0d", size = 494685, upload-time = "2026-10-05T17:41:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2e/7b884014b40573f919fc3a528e5028bc37b249e31a93928ba61bdd25c960/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:674f53ab9d2794e2dd767619a3384bf1006f8d075e43c19d449a645f8ff641c2", size = 855696, upload-time = "2026-10-05T17:41:09.514Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e6/b6e2b4f580ab6ae39241bb9182aca60e6e1915cdad0148faaa04db3f366b/aiohttp-3.14.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6d243221f73e5ac546c2ed9255100423e4bc092b08b944f23498e8cf3096c26c", size = 567931, upload-time = "2026-10-05T17:41:11.685Z" },
+    { url = "https://files.pythonhosted.org/packages/63/99/ae8e3a1a18adcbf636839d18b3cccc51007836ccdae5209381c5cf82d1ae/aiohttp-3.14.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0daa016eb74e7888ed5f9ceec6eea3158999c1c4a115ef5cbe88baa8d924f94c", size = 567421, upload-time = "2026-10-05T17:41:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/63/38/c5d4bb58be72b967a4090d2deeb38571f8c992852936c51dbbbeae49db1c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70c031a622aa20add05ebd234b90adaf6bf51c1c88cc305ec760721af83308c3", size = 2054173, upload-time = "2026-10-05T17:41:16.098Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/3c8a9c7670f56d478a75c5bb84b336fb61a67b908e36c30a4a96ed8c8e86/aiohttp-3.14.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7df363fa7c38945a896e12c69af4a1a56cbd4152791d9e41fd0bac396b72de38", size = 1918296, upload-time = "2026-10-05T17:41:18.478Z" },
+    { url = "https://files.pythonhosted.org/packages/49/97/bd00e499c0a1505b44f5e23b9739034ea9be792ad42537f2894211ba1c07/aiohttp-3.14.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02a508ba5ad91c4d730523584c0adc65882274bba5e37c33bc2f475e37577256", size = 2027513, upload-time = "2026-10-05T17:41:20.874Z" },
+    { url = "https://files.pythonhosted.org/packages/23/1d/a3666a7c224f86a881f18d673a8ffdc92fa4c35274fb4361822f8f0dc566/aiohttp-3.14.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0cb3edece6fe6a944eaf97d803b88f606da6bc1600b1894c2969e78ffdc1fc29", size = 2152686, upload-time = "2026-10-05T17:41:23.181Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/f4204b8c4959c46f6367c182afbbacef08a1b53874281912c52fbd80151c/aiohttp-3.14.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:21ce1223b461bcc5fb389a7204001578f1c0b85c2da60a84d915ebb021294245", size = 2006431, upload-time = "2026-10-05T17:41:25.776Z" },
+    { url = "https://files.pythonhosted.org/packages/33/43/091e69d42967cbea833ceb355c5457f8f70748fe08b88c9d91491b3fafb8/aiohttp-3.14.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35d5432f0dc1c8b71307e9112461b52f336da225e344283eec4779222c0a1dff", size = 1789101, upload-time = "2026-10-05T17:41:28.095Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7b/b57cbe533c01098c5d30471f057e7c3c19f281122f756acc9c716b636e2c/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6ec364493057c118d08292f7cd60865965c209167d8657b45643a26aef77495", size = 1974472, upload-time = "2026-10-05T17:41:30.499Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/44/79acce03611450e4ed8594f96f1cea40d70bc84fb4e918f94d7d9454a4af/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:70492983b7aed9e61bda82fe1ce80bcba9199610886443133783a288638923c0", size = 1956340, upload-time = "2026-10-05T17:41:33.009Z" },
+    { url = "https://files.pythonhosted.org/packages/da/bb/36e6cbd6720e3377a02f8709aec6fe80de729ef41e78ba01f13d50363c73/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a77776673331577147e9d25cd7833a72e8891b47556336cff06ba1569e488b99", size = 1965771, upload-time = "2026-10-05T17:41:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0f/879735ac70ce5e6852916eed51c706a517b205150a8d384f9fa60933a3fc/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:73799000dd6fd5247094fd8e6d3e1eb871e41aab5cc35dff9d9f654cd230bc24", size = 1780297, upload-time = "2026-10-05T17:41:38.284Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/7c030ca5b6baf3b02eccd11afc3d58f0b35e407031d5cc78cae9c24921c0/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:27b370fb532e707e8c96d04fa0c96301fb7dba2d50aaca57f6c456cdfffec5bd", size = 2001374, upload-time = "2026-10-05T17:41:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/ddacbb8141d727034c51dd192d17749521d5b30b03f84aa034325396089e/aiohttp-3.14.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:884e0d1c707b6217fee3080b9b4029eee7551af788ee761010df19be158414b7", size = 1968531, upload-time = "2026-10-05T17:41:43.62Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/08/2214f823701eebc3e57db141faeae76df7bfd415f254cc7c1692258f228d/aiohttp-3.14.4-cp314-cp314t-win32.whl", hash = "sha256:f2e3d34edb151d3e27f93a8338e2da33e2c7261cd4c879ce5f5fe280cc190ea5", size = 504126, upload-time = "2026-10-05T17:41:46.321Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/90e9b6fd23310b4e82d0c0a37b5ecc2944053350473c57533c1da9647235/aiohttp-3.14.4-cp314-cp314t-win_amd64.whl", hash = "sha256:88cf889e51092537fe44adfbff96c2a22d6479d6f92b97b3d413fbfd0a4decf4", size = 531494, upload-time = "2026-10-05T17:41:48.849Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/5b501472c92b9b1dc53742591d6210dccb262962f4721299300d3a9f664b/aiohttp-3.14.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ca450c6d42fda7c0bfaf0e200f32f77c5f2c960a33be1e14d197c84588b7f5f6", size = 510544, upload-time = "2026-10-05T17:41:51.358Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/77/ef165a197850573ea07c8d77bf5f4854a1db12fdb20e1cf0b218abf025fc/aiohttp-3.14.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:3b10799df72f66c30935bc661cb89e5ac2918debfc575e350e226fbaa846cbb7", size = 540737, upload-time = "2026-10-05T17:41:53.761Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/aa/1663f64d1316b3be9d3f6fafa02b8d888070171a6544cba515e82f3af595/aiohttp-3.14.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:7ffd7f9dd39caccc6b2f68ec0339435ecad2b20f6ea2e2b3de91bbe464ac7137", size = 554600, upload-time = "2026-10-05T17:41:56.183Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f7/d4d535855123c1a774a798643e75fdfbac62c047b0c0729d6505d09df444/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a0a7a227353f7693f73878ad14cd2623cafadd656ababcd20e2adfb7225172ea", size = 523184, upload-time = "2026-10-05T17:41:58.624Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/18a8d1cd2958a0b6164b047c18ccb192f2123bb70f1c0a145f6f01f858ad/aiohttp-3.14.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1c43b6af8e4708e8b3812a9ee4f79895207e12d555b7f6d70deb838e0011e12d", size = 530342, upload-time = "2026-10-05T17:42:00.96Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/c4/d1dd2b1fcf8a3192a431375b287a8762ebfd22195ab5b201d3fac30e3a7a/aiohttp-3.14.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:97416b2b997e5e9b817e322b2f0a89b76c54cde22471f51ac17ac15e10901ba0", size = 540629, upload-time = "2026-10-05T17:42:03.324Z" },
+    { url = "https://files.pythonhosted.org/packages/37/51/d1868f3459f618f6b68a6ef549d8b3f76aa616fa083298911fd3ae65d6b9/aiohttp-3.14.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:ee2a5aa31e507c17841d592364f2148393b17f83bc2766e9211e1eb31ea72a70", size = 819347, upload-time = "2026-10-05T17:42:05.713Z" },
+    { url = "https://files.pythonhosted.org/packages/84/e6/53179b721b67e0bd20974d02eca97b5691559e8ce666ba23a65aecda6b7f/aiohttp-3.14.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5d5d9843c34866e986dd24eef713452609e304550c471320ce7b54b3cfb1391e", size = 549825, upload-time = "2026-10-05T17:42:08.093Z" },
+    { url = "https://files.pythonhosted.org/packages/00/0f/d67ddf7a43d4899176954511b6c048328abec1a5df4901f811a3b408a4fc/aiohttp-3.14.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:efcbf93e31b52c21665b6ebc489eb6fdb0dfd86b592edc677b5cffdfa7b11677", size = 549315, upload-time = "2026-10-05T17:42:10.766Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/db/42f372c7f8e259505f239cb49db75f23548deaec56d22c68b4866f1c3fe2/aiohttp-3.14.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f1a79977794592dcf6485ed964ec2448db527a1bc0c72ec89663658dad3a739", size = 1892181, upload-time = "2026-10-05T17:42:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/23/0d/8b1900216302a94f69b41bf0786bb992a6e67d703f4698e335c2442db615/aiohttp-3.14.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:515e7ac6d27509dc3ba2c35fb88970b00b9e7b07ee7cc947c8733dcd54ef5def", size = 1883513, upload-time = "2026-10-05T17:42:15.704Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/15c014313e567fff931ec4a5f81683cc40251257791fbd607ec37c0dad80/aiohttp-3.14.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:185154ffa3b54765b5de96f464f41cfa476f8815a03854ae5e0fe4d48fb06e9c", size = 1933283, upload-time = "2026-10-05T17:42:18.241Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b3/bf7dc39a450218efb1d5c692bac7dc85ef56da282e889bee594f3267211e/aiohttp-3.14.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6aece59f77959628a22cd2ffe48b102cda9611d680e090f204385b3998a1190f", size = 2041054, upload-time = "2026-10-05T17:42:20.728Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/03/ffba18d7aaedb5eafac3f41f0c26621ebb0a740bb0115ea2fae1911d902b/aiohttp-3.14.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7205aa6589f1ad1306c6994ff2e1ab5efabacf938f9ffd7682fb225c197b06a", size = 1895494, upload-time = "2026-10-05T17:42:23.518Z" },
+    { url = "https://files.pythonhosted.org/packages/45/f4/68123365b86826eee82bdceb7fb4c429204cb3a104d6b7ae44bc6a543fcb/aiohttp-3.14.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f38c7b3ce60d55ac0f2a9fd2edc194789d043fefea15cfb7dcb40b7d5f561146", size = 1714098, upload-time = "2026-10-05T17:42:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/db/b13c0b214afc571782e8667f3b9e0bbed6843397be90fa35acf2f3ecfbb0/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:b0a1274ee4ee6203c15a341cce87f9f3df8151d5496047b3608bb62bd969cffc", size = 1857111, upload-time = "2026-10-05T17:42:29.169Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/7f/4f5d3cee3c23b57119aebba5174962fed0bc493f37f38edab2f5730411b6/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:69ce2407951516f413adf3132b88451eababd710ce631f83c81a9603a3640253", size = 1892123, upload-time = "2026-10-05T17:42:31.786Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2e/5a6a1f014c4e17d58d4e935d0dd64e612f4eaa2f33cca2475b48ca5e3fb5/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:b84d3d057c60eb8e0c2b457a1203e868d82709d3f0c272a4975dfd88c2414939", size = 1898809, upload-time = "2026-10-05T17:42:34.34Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f3/d1cca5311a70fcc1c7c2082e02044578a69bcb10686db33a322df9fb849e/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4ecc84f69c9e217984f6877e832e4786a74567432c0bf2b7512919fbdfe18ade", size = 1704814, upload-time = "2026-10-05T17:42:37.047Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/cb/cd58eae366148a5b9b1baa233542151154f2b72cd32daa39fd9db97d0c0d/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:878f2d7950238b2b0a8cbb88054444a125f0cfbc77f54c811aca0483132a9be3", size = 1918390, upload-time = "2026-10-05T17:42:39.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d8/f5e6c4939432734033048ba631503edf4a1e693ee5e261773e169803bbe4/aiohttp-3.14.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6ff9d3a0e6935f1cb0a6685f9f4b3f0d3e406456d7a434a03cf309b8cd5d7a2e", size = 1878321, upload-time = "2026-10-05T17:42:42.528Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/71/462957d6b5d4eb208f78e67745c41480bad2e738aa7caf1d9b07536920c1/aiohttp-3.14.4-cp315-cp315-win32.whl", hash = "sha256:e07dfd7cd360f20be26dc2487ad4c7f21b0b39fdd593e9ebf37d2424ad52defb", size = 485536, upload-time = "2026-10-05T17:42:45.223Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/6e/48f59266a8b8c6420894ff59b8e74175252da67df85967b96997e96b7092/aiohttp-3.14.4-cp315-cp315-win_amd64.whl", hash = "sha256:921fc4f1ad549091bfc39cb5e93925b04f307f83517756a3111843851130efce", size = 512087, upload-time = "2026-10-05T17:42:47.717Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/46263b23cee4f312e28aaabbdec2e074c807700a12c9dfa18beff461f035/aiohttp-3.14.4-cp315-cp315-win_arm64.whl", hash = "sha256:5be8af106f96fd625f6c264fa9faaaa9e0104089684d9015d2fa5b6eba6407c7", size = 494709, upload-time = "2026-10-05T17:42:50.615Z" },
+    { url = "https://files.pythonhosted.org/packages/77/8d/e3b1d406c95a8fe436ae2e5f01ee9591196c6c22c44c645b24f20d73eaea/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e69727ec04a4608200ff32ec29478299df7657e2eb78c416ae338d0ca6662596", size = 856014, upload-time = "2026-10-05T17:42:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/fc/e9e78d1097830040bc0a4b8af073379f964064bfa7f0a852d774f96f3168/aiohttp-3.14.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f8b658dd3ef2ebd7708b311ed96ff7cb5edaca001a30018a091504ef492bcb1c", size = 567724, upload-time = "2026-10-05T17:42:56.416Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ad/c813a705a1da1c111c30723b52e1efb67763e9f0b3b54a418cb419616e7a/aiohttp-3.14.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3749e018123df1205161a73ba96d336e17e9cf6b947295e53a43571de420e7b1", size = 567888, upload-time = "2026-10-05T17:42:59.048Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/1f/7676f46aa24554a45686853c61552d02d67ade2b4c51adfe8b2ec4fdecd2/aiohttp-3.14.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f28a3c4fca436b2e594090e7cd22558f5e93a30ca18516c436de982da6fc25a", size = 2054356, upload-time = "2026-10-05T17:43:01.781Z" },
+    { url = "https://files.pythonhosted.org/packages/44/79/b9ef7d7442061e0a3125990d6021230b30361a972f7b8ebfb011042877ce/aiohttp-3.14.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e099aae21246992a1d84303ff262262d054c474e46cace33b0d5a69810c71877", size = 1937678, upload-time = "2026-10-05T17:43:04.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/98/5927a31540c8e6d0542effead5bd5c56e749a9d99d84e902fb80ae906ef8/aiohttp-3.14.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fafb521891e646d9cf5da89f01c75e7159d08be7254a024149630a698be28251", size = 2026705, upload-time = "2026-10-05T17:43:07.353Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bd/1be001ed97dcfa57a292188c38979fb78be795b960b50f02660587bffa06/aiohttp-3.14.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d385db2cd154bce0b3dd451cf2a52bec91ebb7be2c3a5d06b14b4391631d807", size = 2147075, upload-time = "2026-10-05T17:43:10.141Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/f7/d59628ccedd7c86db4c1f904467d1c80fed6cc10a1831ed5d75ff12e5a71/aiohttp-3.14.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae8a244889d8a53549851bf595b9f382f64acca57e8762da1ecb26ba786828f7", size = 2005016, upload-time = "2026-10-05T17:43:12.848Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/dc/472db3ab1daafa12a61d7f83314f85f502b99c143c78d66554a5e24361fd/aiohttp-3.14.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:681dde68ff8d8d5e7d5abcad4feb45bfb457a218310c919825e21fc36cac3d0b", size = 1796363, upload-time = "2026-10-05T17:43:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/08/61/6f9834b131b9a42e30d68c469c196033d3cae2d8fe340d4668f362c4fd1f/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b91a6441fcaed88ca7bca67726b189332df3ceb6ac0dfc98dcb9654bb723288c", size = 1974240, upload-time = "2026-10-05T17:43:18.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2f/b8eb2a276685ef1da7f7bc15348404b8b9ee12b8f32f2cd8895385cd1589/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:f15dbbac49bc15eaff95c0b8166525c4050996af578c7be141e145f40ee2cf24", size = 1973387, upload-time = "2026-10-05T17:43:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/32/ad559b2d6817e85f7cb294d8641e975e64b526f4da98ffe941c9af67a047/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:7abae043e87692d1c2adda1fab501bb0612d28c4a23eb082005c1e684f792dac", size = 1968766, upload-time = "2026-10-05T17:43:24.544Z" },
+    { url = "https://files.pythonhosted.org/packages/60/67/4a16e398140bdabb363428b9f439af3f77706a6df8bea6e626bbde53c2ab/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:21f4624fb1051fc1aa10d57a636a80e829f7d0417462d6f1ce380b08fe1a904c", size = 1788193, upload-time = "2026-10-05T17:43:27.467Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/38/17b326da7f52e530a675d789ade3e727a1b3db9959722f6049b9c392321a/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:2e8dc3a0fdaf9d12b954d3d06cc4c355d91b17fb6c671715b593624ca4c379f8", size = 1999645, upload-time = "2026-10-05T17:43:30.32Z" },
+    { url = "https://files.pythonhosted.org/packages/53/dc/91b87961250010e05eb3adabaf0d98e4229ee7543147c265e834922e1b0b/aiohttp-3.14.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:1410b6f6e3d52ea7c02c950496522ce6e85d5543bf154bc80a6141e505251cfa", size = 1970998, upload-time = "2026-10-05T17:43:33.364Z" },
+    { url = "https://files.pythonhosted.org/packages/72/66/9bcf2c2db7b75a3b51c11470ceb67941d028727d674276ff5d5120adc87e/aiohttp-3.14.4-cp315-cp315t-win32.whl", hash = "sha256:a65189a89f3e621f7c27a968b5131bbca29126e2b8517dc72b205747a39d4c96", size = 504036, upload-time = "2026-10-05T17:43:36.212Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/20/349db4af12dbc16070d32028d30c2067123b4520f3dcb2d9013524efeb4f/aiohttp-3.14.4-cp315-cp315t-win_amd64.whl", hash = "sha256:2b2c95f5f769eec92b552969db1f79ea0282058ce5131ed0f2fa540b4af3f14e", size = 531284, upload-time = "2026-10-05T17:43:39.362Z" },
+    { url = "https://files.pythonhosted.org/packages/26/21/544c711bc5fad611278ebd153bdcab1bffce8b8581f8ec9096b275948a3c/aiohttp-3.14.4-cp315-cp315t-win_arm64.whl", hash = "sha256:54209fff79346ee1ef0d5cbf92fa80a5bb37396406bb4d932e5107f9c29b2d3f", size = 510623, upload-time = "2026-10-05T17:43:42.15Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/27/5e1f8446545be98e9416af59c396b1ed1f9f3294afb0a40ee3a709889273/aiohttp-3.14.4-py3-none-any.whl", hash = "sha256:5c6758ba62aea282c537179cfc8474a90f2b5f7b089cc5ff66d8920d86a9bfdd", size = 279487, upload-time = "2026-10-05T17:43:44.905Z" },
 ]
 
 [[package]]
@@ -1969,7 +2011,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.70.2"
+version = "7.73.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -3125,142 +3167,152 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.23.0"
+version = "1.25.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
     { name = "propcache" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/0d/9cc638702f6fc3c7a3685bcc8cf2a9ed7d6206e932a49f5242658047ef51/yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107", size = 123764, upload-time = "2026-03-01T22:04:09.7Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/35/5a553687c5793df5429cd1db45909d4f3af7eee90014888c208d086a44f0/yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d", size = 86282, upload-time = "2026-03-01T22:04:11.892Z" },
-    { url = "https://files.pythonhosted.org/packages/68/2e/c5a2234238f8ce37a8312b52801ee74117f576b1539eec8404a480434acc/yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05", size = 86053, upload-time = "2026-03-01T22:04:13.292Z" },
-    { url = "https://files.pythonhosted.org/packages/74/3f/bbd8ff36fb038622797ffbaf7db314918bb4d76f1cc8a4f9ca7a55fe5195/yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d", size = 99395, upload-time = "2026-03-01T22:04:15.133Z" },
-    { url = "https://files.pythonhosted.org/packages/77/04/9516bc4e269d2a3ec9c6779fcdeac51ce5b3a9b0156f06ac7152e5bba864/yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748", size = 92143, upload-time = "2026-03-01T22:04:16.829Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/63/88802d1f6b1cb1fc67d67a58cd0cf8a1790de4ce7946e434240f1d60ab4a/yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764", size = 107643, upload-time = "2026-03-01T22:04:18.519Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/db/4f9b838f4d8bdd6f0f385aed8bbf21c71ed11a0b9983305c302cbd557815/yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007", size = 108700, upload-time = "2026-03-01T22:04:20.373Z" },
-    { url = "https://files.pythonhosted.org/packages/50/12/95a1d33f04a79c402664070d43b8b9f72dc18914e135b345b611b0b1f8cc/yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4", size = 102769, upload-time = "2026-03-01T22:04:23.055Z" },
-    { url = "https://files.pythonhosted.org/packages/86/65/91a0285f51321369fd1a8308aa19207520c5f0587772cfc2e03fc2467e90/yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26", size = 101114, upload-time = "2026-03-01T22:04:25.031Z" },
-    { url = "https://files.pythonhosted.org/packages/58/80/c7c8244fc3e5bc483dc71a09560f43b619fab29301a0f0a8f936e42865c7/yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769", size = 98883, upload-time = "2026-03-01T22:04:27.281Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e7/71ca9cc9ca79c0b7d491216177d1aed559d632947b8ffb0ee60f7d8b23e3/yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716", size = 94172, upload-time = "2026-03-01T22:04:28.554Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/3f/6c6c8a0fe29c26fb2db2e8d32195bb84ec1bfb8f1d32e7f73b787fcf349b/yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993", size = 107010, upload-time = "2026-03-01T22:04:30.385Z" },
-    { url = "https://files.pythonhosted.org/packages/56/38/12730c05e5ad40a76374d440ed8b0899729a96c250516d91c620a6e38fc2/yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0", size = 100285, upload-time = "2026-03-01T22:04:31.752Z" },
-    { url = "https://files.pythonhosted.org/packages/34/92/6a7be9239f2347234e027284e7a5f74b1140cc86575e7b469d13fba1ebfe/yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750", size = 108230, upload-time = "2026-03-01T22:04:33.844Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/81/4aebccfa9376bd98b9d8bfad20621a57d3e8cfc5b8631c1fa5f62cdd03f4/yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6", size = 103008, upload-time = "2026-03-01T22:04:35.856Z" },
-    { url = "https://files.pythonhosted.org/packages/38/0f/0b4e3edcec794a86b853b0c6396c0a888d72dfce19b2d88c02ac289fb6c1/yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d", size = 83073, upload-time = "2026-03-01T22:04:38.268Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/71/ad95c33da18897e4c636528bbc24a1dd23fe16797de8bc4ec667b8db0ba4/yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb", size = 87328, upload-time = "2026-03-01T22:04:39.558Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/14/dfa369523c79bccf9c9c746b0a63eb31f65db9418ac01275f7950962e504/yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220", size = 82463, upload-time = "2026-03-01T22:04:41.454Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/aa/60da938b8f0997ba3a911263c40d82b6f645a67902a490b46f3355e10fae/yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99", size = 123641, upload-time = "2026-03-01T22:04:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/24/84/e237607faf4e099dbb8a4f511cfd5efcb5f75918baad200ff7380635631b/yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c", size = 86248, upload-time = "2026-03-01T22:04:44.757Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/0d/71ceabc14c146ba8ee3804ca7b3d42b1664c8440439de5214d366fec7d3a/yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432", size = 85988, upload-time = "2026-03-01T22:04:46.365Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/6c/4a90d59c572e46b270ca132aca66954f1175abd691f74c1ef4c6711828e2/yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a", size = 100566, upload-time = "2026-03-01T22:04:47.639Z" },
-    { url = "https://files.pythonhosted.org/packages/49/fb/c438fb5108047e629f6282a371e6e91cf3f97ee087c4fb748a1f32ceef55/yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05", size = 92079, upload-time = "2026-03-01T22:04:48.925Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/13/d269aa1aed3e4f50a5a103f96327210cc5fa5dd2d50882778f13c7a14606/yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83", size = 108741, upload-time = "2026-03-01T22:04:50.838Z" },
-    { url = "https://files.pythonhosted.org/packages/85/fb/115b16f22c37ea4437d323e472945bea97301c8ec6089868fa560abab590/yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c", size = 108099, upload-time = "2026-03-01T22:04:52.499Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/64/c53487d9f4968045b8afa51aed7ca44f58b2589e772f32745f3744476c82/yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598", size = 102678, upload-time = "2026-03-01T22:04:55.176Z" },
-    { url = "https://files.pythonhosted.org/packages/85/59/cd98e556fbb2bf8fab29c1a722f67ad45c5f3447cac798ab85620d1e70af/yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b", size = 100803, upload-time = "2026-03-01T22:04:56.588Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/c0/b39770b56d4a9f0bb5f77e2f1763cd2d75cc2f6c0131e3b4c360348fcd65/yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c", size = 100163, upload-time = "2026-03-01T22:04:58.492Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/64/6980f99ab00e1f0ff67cb84766c93d595b067eed07439cfccfc8fb28c1a6/yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788", size = 93859, upload-time = "2026-03-01T22:05:00.268Z" },
-    { url = "https://files.pythonhosted.org/packages/38/69/912e6c5e146793e5d4b5fe39ff5b00f4d22463dfd5a162bec565ac757673/yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222", size = 108202, upload-time = "2026-03-01T22:05:02.273Z" },
-    { url = "https://files.pythonhosted.org/packages/59/97/35ca6767524687ad64e5f5c31ad54bc76d585585a9fcb40f649e7e82ffed/yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb", size = 99866, upload-time = "2026-03-01T22:05:03.597Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/1c/1a3387ee6d73589f6f2a220ae06f2984f6c20b40c734989b0a44f5987308/yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc", size = 107852, upload-time = "2026-03-01T22:05:04.986Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/b8/35c0750fcd5a3f781058bfd954515dd4b1eab45e218cbb85cf11132215f1/yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2", size = 102919, upload-time = "2026-03-01T22:05:06.397Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1c/9a1979aec4a81896d597bcb2177827f2dbee3f5b7cc48b2d0dadb644b41d/yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5", size = 82602, upload-time = "2026-03-01T22:05:08.444Z" },
-    { url = "https://files.pythonhosted.org/packages/93/22/b85eca6fa2ad9491af48c973e4c8cf6b103a73dbb271fe3346949449fca0/yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46", size = 87461, upload-time = "2026-03-01T22:05:10.145Z" },
-    { url = "https://files.pythonhosted.org/packages/93/95/07e3553fe6f113e6864a20bdc53a78113cda3b9ced8784ee52a52c9f80d8/yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928", size = 82336, upload-time = "2026-03-01T22:05:11.554Z" },
-    { url = "https://files.pythonhosted.org/packages/88/8a/94615bc31022f711add374097ad4144d569e95ff3c38d39215d07ac153a0/yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860", size = 124737, upload-time = "2026-03-01T22:05:12.897Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/6f/c6554045d59d64052698add01226bc867b52fe4a12373415d7991fdca95d/yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069", size = 87029, upload-time = "2026-03-01T22:05:14.376Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/725ecc166d53438bc88f76822ed4b1e3b10756e790bafd7b523fe97c322d/yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25", size = 86310, upload-time = "2026-03-01T22:05:15.71Z" },
-    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
-    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
-    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
-    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
-    { url = "https://files.pythonhosted.org/packages/69/7f/cd5ef733f2550de6241bd8bd8c3febc78158b9d75f197d9c7baa113436af/yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d", size = 82359, upload-time = "2026-03-01T22:05:36.811Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/be/25216a49daeeb7af2bec0db22d5e7df08ed1d7c9f65d78b14f3b74fd72fc/yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e", size = 87674, upload-time = "2026-03-01T22:05:38.171Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/35/aeab955d6c425b227d5b7247eafb24f2653fedc32f95373a001af5dfeb9e/yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9", size = 81879, upload-time = "2026-03-01T22:05:40.006Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4b/a0a6e5d0ee8a2f3a373ddef8a4097d74ac901ac363eea1440464ccbe0898/yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e", size = 123796, upload-time = "2026-03-01T22:05:41.412Z" },
-    { url = "https://files.pythonhosted.org/packages/67/b6/8925d68af039b835ae876db5838e82e76ec87b9782ecc97e192b809c4831/yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5", size = 86547, upload-time = "2026-03-01T22:05:42.841Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/50/06d511cc4b8e0360d3c94af051a768e84b755c5eb031b12adaaab6dec6e5/yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b", size = 85854, upload-time = "2026-03-01T22:05:44.85Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/f4/4e30b250927ffdab4db70da08b9b8d2194d7c7b400167b8fbeca1e4701ca/yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035", size = 98351, upload-time = "2026-03-01T22:05:46.836Z" },
-    { url = "https://files.pythonhosted.org/packages/86/fc/4118c5671ea948208bdb1492d8b76bdf1453d3e73df051f939f563e7dcc5/yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5", size = 92711, upload-time = "2026-03-01T22:05:48.316Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/1ed91d42bd9e73c13dc9e7eb0dd92298d75e7ac4dd7f046ad0c472e231cd/yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735", size = 106014, upload-time = "2026-03-01T22:05:50.028Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/c9/74e44e056a23fbc33aca71779ef450ca648a5bc472bdad7a82339918f818/yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401", size = 105557, upload-time = "2026-03-01T22:05:51.416Z" },
-    { url = "https://files.pythonhosted.org/packages/66/fe/b1e10b08d287f518994f1e2ff9b6d26f0adeecd8dd7d533b01bab29a3eda/yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4", size = 101559, upload-time = "2026-03-01T22:05:52.872Z" },
-    { url = "https://files.pythonhosted.org/packages/72/59/c5b8d94b14e3d3c2a9c20cb100119fd534ab5a14b93673ab4cc4a4141ea5/yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f", size = 100502, upload-time = "2026-03-01T22:05:54.954Z" },
-    { url = "https://files.pythonhosted.org/packages/77/4f/96976cb54cbfc5c9fd73ed4c51804f92f209481d1fb190981c0f8a07a1d7/yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a", size = 98027, upload-time = "2026-03-01T22:05:56.409Z" },
-    { url = "https://files.pythonhosted.org/packages/63/6e/904c4f476471afdbad6b7e5b70362fb5810e35cd7466529a97322b6f5556/yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2", size = 95369, upload-time = "2026-03-01T22:05:58.141Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/40/acfcdb3b5f9d68ef499e39e04d25e141fe90661f9d54114556cf83be8353/yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f", size = 105565, upload-time = "2026-03-01T22:06:00.286Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/c6/31e28f3a6ba2869c43d124f37ea5260cac9c9281df803c354b31f4dd1f3c/yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b", size = 99813, upload-time = "2026-03-01T22:06:01.712Z" },
-    { url = "https://files.pythonhosted.org/packages/08/1f/6f65f59e72d54aa467119b63fc0b0b1762eff0232db1f4720cd89e2f4a17/yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a", size = 105632, upload-time = "2026-03-01T22:06:03.188Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/c4/18b178a69935f9e7a338127d5b77d868fdc0f0e49becd286d51b3a18c61d/yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543", size = 101895, upload-time = "2026-03-01T22:06:04.651Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/54/f5b870b5505663911dba950a8e4776a0dbd51c9c54c0ae88e823e4b874a0/yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957", size = 82356, upload-time = "2026-03-01T22:06:06.04Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/84/266e8da36879c6edcd37b02b547e2d9ecdfea776be49598e75696e3316e1/yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3", size = 87515, upload-time = "2026-03-01T22:06:08.107Z" },
-    { url = "https://files.pythonhosted.org/packages/00/fd/7e1c66efad35e1649114fa13f17485f62881ad58edeeb7f49f8c5e748bf9/yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3", size = 81785, upload-time = "2026-03-01T22:06:10.181Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/fc/119dd07004f17ea43bb91e3ece6587759edd7519d6b086d16bfbd3319982/yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa", size = 130719, upload-time = "2026-03-01T22:06:11.708Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/0d/9f2348502fbb3af409e8f47730282cd6bc80dec6630c1e06374d882d6eb2/yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120", size = 89690, upload-time = "2026-03-01T22:06:13.429Z" },
-    { url = "https://files.pythonhosted.org/packages/50/93/e88f3c80971b42cfc83f50a51b9d165a1dbf154b97005f2994a79f212a07/yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59", size = 89851, upload-time = "2026-03-01T22:06:15.53Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/07/61c9dd8ba8f86473263b4036f70fb594c09e99c0d9737a799dfd8bc85651/yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512", size = 95874, upload-time = "2026-03-01T22:06:17.553Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/f9ff8ceefba599eac6abddcfb0b3bee9b9e636e96dbf54342a8577252379/yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4", size = 88710, upload-time = "2026-03-01T22:06:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/78/0231bfcc5d4c8eec220bc2f9ef82cb4566192ea867a7c5b4148f44f6cbcd/yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1", size = 101033, upload-time = "2026-03-01T22:06:21.203Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/9b/30ea5239a61786f18fd25797151a17fbb3be176977187a48d541b5447dd4/yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea", size = 100817, upload-time = "2026-03-01T22:06:22.738Z" },
-    { url = "https://files.pythonhosted.org/packages/62/e2/a4980481071791bc83bce2b7a1a1f7adcabfa366007518b4b845e92eeee3/yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9", size = 97482, upload-time = "2026-03-01T22:06:24.21Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/1e/304a00cf5f6100414c4b5a01fc7ff9ee724b62158a08df2f8170dfc72a2d/yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123", size = 95949, upload-time = "2026-03-01T22:06:25.697Z" },
-    { url = "https://files.pythonhosted.org/packages/68/03/093f4055ed4cae649ac53bca3d180bd37102e9e11d048588e9ab0c0108d0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24", size = 95839, upload-time = "2026-03-01T22:06:27.309Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/28/4c75ebb108f322aa8f917ae10a8ffa4f07cae10a8a627b64e578617df6a0/yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de", size = 90696, upload-time = "2026-03-01T22:06:29.048Z" },
-    { url = "https://files.pythonhosted.org/packages/23/9c/42c2e2dd91c1a570402f51bdf066bfdb1241c2240ba001967bad778e77b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b", size = 100865, upload-time = "2026-03-01T22:06:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/74/05/1bcd60a8a0a914d462c305137246b6f9d167628d73568505fce3f1cb2e65/yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6", size = 96234, upload-time = "2026-03-01T22:06:32.692Z" },
-    { url = "https://files.pythonhosted.org/packages/90/b2/f52381aac396d6778ce516b7bc149c79e65bfc068b5de2857ab69eeea3b7/yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6", size = 100295, upload-time = "2026-03-01T22:06:34.268Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/e8/638bae5bbf1113a659b2435d8895474598afe38b4a837103764f603aba56/yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5", size = 97784, upload-time = "2026-03-01T22:06:35.864Z" },
-    { url = "https://files.pythonhosted.org/packages/80/25/a3892b46182c586c202629fc2159aa13975d3741d52ebd7347fd501d48d5/yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595", size = 88313, upload-time = "2026-03-01T22:06:37.39Z" },
-    { url = "https://files.pythonhosted.org/packages/43/68/8c5b36aa5178900b37387937bc2c2fe0e9505537f713495472dcf6f6fccc/yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090", size = 94932, upload-time = "2026-03-01T22:06:39.579Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/cc/d79ba8292f51f81f4dc533a8ccfb9fc6992cabf0998ed3245de7589dc07c/yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144", size = 84786, upload-time = "2026-03-01T22:06:41.988Z" },
-    { url = "https://files.pythonhosted.org/packages/90/98/b85a038d65d1b92c3903ab89444f48d3cee490a883477b716d7a24b1a78c/yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912", size = 124455, upload-time = "2026-03-01T22:06:43.615Z" },
-    { url = "https://files.pythonhosted.org/packages/39/54/bc2b45559f86543d163b6e294417a107bb87557609007c007ad889afec18/yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474", size = 86752, upload-time = "2026-03-01T22:06:45.425Z" },
-    { url = "https://files.pythonhosted.org/packages/24/f9/e8242b68362bffe6fb536c8db5076861466fc780f0f1b479fc4ffbebb128/yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719", size = 86291, upload-time = "2026-03-01T22:06:46.974Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/d8/d1cb2378c81dd729e98c716582b1ccb08357e8488e4c24714658cc6630e8/yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319", size = 99026, upload-time = "2026-03-01T22:06:48.459Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/ff/7196790538f31debe3341283b5b0707e7feb947620fc5e8236ef28d44f72/yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434", size = 92355, upload-time = "2026-03-01T22:06:50.306Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/56/25d58c3eddde825890a5fe6aa1866228377354a3c39262235234ab5f616b/yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723", size = 106417, upload-time = "2026-03-01T22:06:52.1Z" },
-    { url = "https://files.pythonhosted.org/packages/51/8a/882c0e7bc8277eb895b31bce0138f51a1ba551fc2e1ec6753ffc1e7c1377/yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039", size = 106422, upload-time = "2026-03-01T22:06:54.424Z" },
-    { url = "https://files.pythonhosted.org/packages/42/2b/fef67d616931055bf3d6764885990a3ac647d68734a2d6a9e1d13de437a2/yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52", size = 101915, upload-time = "2026-03-01T22:06:55.895Z" },
-    { url = "https://files.pythonhosted.org/packages/18/6a/530e16aebce27c5937920f3431c628a29a4b6b430fab3fd1c117b26ff3f6/yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c", size = 100690, upload-time = "2026-03-01T22:06:58.21Z" },
-    { url = "https://files.pythonhosted.org/packages/88/08/93749219179a45e27b036e03260fda05190b911de8e18225c294ac95bbc9/yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae", size = 98750, upload-time = "2026-03-01T22:06:59.794Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/cf/ea424a004969f5d81a362110a6ac1496d79efdc6d50c2c4b2e3ea0fc2519/yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e", size = 94685, upload-time = "2026-03-01T22:07:01.375Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/b7/14341481fe568e2b0408bcf1484c652accafe06a0ade9387b5d3fd9df446/yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85", size = 106009, upload-time = "2026-03-01T22:07:03.151Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/e6/5c744a9b54f4e8007ad35bce96fbc9218338e84812d36f3390cea616881a/yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd", size = 100033, upload-time = "2026-03-01T22:07:04.701Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/23/e3bfc188d0b400f025bc49d99793d02c9abe15752138dcc27e4eaf0c4a9e/yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6", size = 106483, upload-time = "2026-03-01T22:07:06.231Z" },
-    { url = "https://files.pythonhosted.org/packages/72/42/f0505f949a90b3f8b7a363d6cbdf398f6e6c58946d85c6d3a3bc70595b26/yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe", size = 102175, upload-time = "2026-03-01T22:07:08.4Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/65/b39290f1d892a9dd671d1c722014ca062a9c35d60885d57e5375db0404b5/yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169", size = 83871, upload-time = "2026-03-01T22:07:09.968Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/5b/9b92f54c784c26e2a422e55a8d2607ab15b7ea3349e28359282f84f01d43/yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70", size = 89093, upload-time = "2026-03-01T22:07:11.501Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/7d/8a84dc9381fd4412d5e7ff04926f9865f6372b4c2fd91e10092e65d29eb8/yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e", size = 83384, upload-time = "2026-03-01T22:07:13.069Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/8d/d2fad34b1c08aa161b74394183daa7d800141aaaee207317e82c790b418d/yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679", size = 131019, upload-time = "2026-03-01T22:07:14.903Z" },
-    { url = "https://files.pythonhosted.org/packages/19/ff/33009a39d3ccf4b94d7d7880dfe17fb5816c5a4fe0096d9b56abceea9ac7/yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412", size = 89894, upload-time = "2026-03-01T22:07:17.372Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/f1/dab7ac5e7306fb79c0190766a3c00b4cb8d09a1f390ded68c85a5934faf5/yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4", size = 89979, upload-time = "2026-03-01T22:07:19.361Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/b1/08e95f3caee1fad6e65017b9f26c1d79877b502622d60e517de01e72f95d/yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c", size = 95943, upload-time = "2026-03-01T22:07:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/cc/6409f9018864a6aa186c61175b977131f373f1988e198e031236916e87e4/yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4", size = 88786, upload-time = "2026-03-01T22:07:23.129Z" },
-    { url = "https://files.pythonhosted.org/packages/76/40/cc22d1d7714b717fde2006fad2ced5efe5580606cb059ae42117542122f3/yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94", size = 101307, upload-time = "2026-03-01T22:07:24.689Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/0d/476c38e85ddb4c6ec6b20b815bdd779aa386a013f3d8b85516feee55c8dc/yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28", size = 100904, upload-time = "2026-03-01T22:07:26.287Z" },
-    { url = "https://files.pythonhosted.org/packages/72/32/0abe4a76d59adf2081dcb0397168553ece4616ada1c54d1c49d8936c74f8/yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6", size = 97728, upload-time = "2026-03-01T22:07:27.906Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/35/7b30f4810fba112f60f5a43237545867504e15b1c7647a785fbaf588fac2/yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277", size = 95964, upload-time = "2026-03-01T22:07:30.198Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/86/ed7a73ab85ef00e8bb70b0cb5421d8a2a625b81a333941a469a6f4022828/yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4", size = 95882, upload-time = "2026-03-01T22:07:32.132Z" },
-    { url = "https://files.pythonhosted.org/packages/19/90/d56967f61a29d8498efb7afb651e0b2b422a1e9b47b0ab5f4e40a19b699b/yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a", size = 90797, upload-time = "2026-03-01T22:07:34.404Z" },
-    { url = "https://files.pythonhosted.org/packages/72/00/8b8f76909259f56647adb1011d7ed8b321bcf97e464515c65016a47ecdf0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb", size = 101023, upload-time = "2026-03-01T22:07:35.953Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e2/cab11b126fb7d440281b7df8e9ddbe4851e70a4dde47a202b6642586b8d9/yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41", size = 96227, upload-time = "2026-03-01T22:07:37.594Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/9b/2c893e16bfc50e6b2edf76c1a9eb6cb0c744346197e74c65e99ad8d634d0/yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2", size = 100302, upload-time = "2026-03-01T22:07:39.334Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ec/5498c4e3a6d5f1003beb23405671c2eb9cdbf3067d1c80f15eeafe301010/yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4", size = 98202, upload-time = "2026-03-01T22:07:41.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/c3/cd737e2d45e70717907f83e146f6949f20cc23cd4bf7b2688727763aa458/yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4", size = 90558, upload-time = "2026-03-01T22:07:43.433Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/19/3774d162f6732d1cfb0b47b4140a942a35ca82bb19b6db1f80e9e7bdc8f8/yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2", size = 97610, upload-time = "2026-03-01T22:07:45.773Z" },
-    { url = "https://files.pythonhosted.org/packages/51/47/3fa2286c3cb162c71cdb34c4224d5745a1ceceb391b2bd9b19b668a8d724/yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25", size = 86041, upload-time = "2026-03-01T22:07:49.026Z" },
-    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" },
+    { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" },
+    { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" },
+    { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" },
+    { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" },
+    { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" },
+    { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" },
+    { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" },
+    { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" },
+    { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" },
+    { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" },
+    { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" },
+    { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" },
+    { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" },
+    { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" },
+    { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" },
+    { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" },
+    { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" },
+    { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" },
+    { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" },
+    { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" },
+    { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" },
+    { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" },
+    { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" },
+    { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" },
+    { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" },
+    { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" },
+    { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" },
+    { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" },
+    { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" },
+    { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" },
+    { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
+    { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
 
 [[package]]

From 63b5dcca4ebaf3d42fee4cf6c9639e516dc2df4a Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Tue, 20 Oct 2026 17:06:45 -0400
Subject: [PATCH 055/245] fix(flags): compare numeric string properties
 numerically (#1088)

---
 .../numeric-string-flag-comparisons.md        |   5 +
 posthog/feature_flags.py                      |  61 ++---
 posthog/test/test_feature_flags.py            | 223 +++++++++++++++++-
 3 files changed, 252 insertions(+), 37 deletions(-)
 create mode 100644 .sampo/changesets/numeric-string-flag-comparisons.md

diff --git a/.sampo/changesets/numeric-string-flag-comparisons.md b/.sampo/changesets/numeric-string-flag-comparisons.md
new file mode 100644
index 000000000..b544a8ee4
--- /dev/null
+++ b/.sampo/changesets/numeric-string-flag-comparisons.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Fix local feature flag `gt`, `gte`, `lt`, and `lte` comparisons to compare numeric strings numerically rather than lexicographically. This can change which users match flags targeting numeric-string properties. Only complete, unpadded decimal strings and finite numbers are accepted: invalid properties no longer compare lexicographically, and invalid filter values allow remote evaluation fallback.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index 87da025b5..7545306ea 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -643,6 +643,23 @@ def _is_truthy_property_value(value) -> bool:
     return False
 
 
+_NUMERIC_STRING_PATTERN = re.compile(
+    r"[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?"
+)
+
+
+def _parse_numeric_value(value) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, (str, int, float, Decimal)):
+        return None
+    if isinstance(value, str) and not _NUMERIC_STRING_PATTERN.fullmatch(value):
+        return None
+    try:
+        parsed = float(value)
+    except (ValueError, OverflowError):
+        return None
+    return parsed if math.isfinite(parsed) else None
+
+
 def match_property(
     property, property_values, property_matching_version: int = 1
 ) -> bool:
@@ -664,6 +681,21 @@ def match_property(
 
     override_value = property_values[key]
 
+    if operator in NUMERIC_OPERATORS:
+        parsed_value = _parse_numeric_value(value)
+        if parsed_value is None:
+            raise InconclusiveMatchError("The numeric condition is not a finite number")
+        parsed_override = _parse_numeric_value(override_value)
+        if parsed_override is None:
+            return False
+        if operator == "gt":
+            return parsed_override > parsed_value
+        if operator == "gte":
+            return parsed_override >= parsed_value
+        if operator == "lt":
+            return parsed_override < parsed_value
+        return parsed_override <= parsed_value
+
     if (
         operator not in NONE_VALUES_ALLOWED_OPERATORS
         and operator != "exact"
@@ -730,35 +762,6 @@ def compute_exact_match(value, override_value):
             and re.compile(str(value)).search(str(override_value)) is None
         )
 
-    if operator in ("gt", "gte", "lt", "lte"):
-        # :TRICKY: We adjust comparison based on the override value passed in,
-        # to make sure we handle both numeric and string comparisons appropriately.
-        def compare(lhs, rhs, operator):
-            if operator == "gt":
-                return lhs > rhs
-            elif operator == "gte":
-                return lhs >= rhs
-            elif operator == "lt":
-                return lhs < rhs
-            elif operator == "lte":
-                return lhs <= rhs
-            else:
-                raise ValueError(f"Invalid operator: {operator}")
-
-        parsed_value = None
-        try:
-            parsed_value = float(value)
-        except Exception:
-            pass
-
-        if parsed_value is not None and override_value is not None:
-            if isinstance(override_value, str):
-                return compare(override_value, str(value), operator)
-            else:
-                return compare(override_value, parsed_value, operator)
-        else:
-            return compare(str(override_value), str(value), operator)
-
     if operator in ["is_date_before", "is_date_after"]:
         try:
             parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index a126a0092..374cb3259 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -3,6 +3,7 @@
 import threading
 import unittest
 
+from decimal import Decimal
 from unittest import mock
 from zoneinfo import ZoneInfo
 from dateutil import parser
@@ -118,6 +119,105 @@ def test_missing_nested_cohort_always_requires_server_evaluation(self):
                     )
 
 
+class TestNumericOrderingLocalEvaluation(unittest.TestCase):
+    def setUp(self):
+        self.client = Client(FAKE_TEST_API_KEY)
+
+    def tearDown(self):
+        self.client.shutdown()
+
+    @parameterized.expand([("get_feature_flag",), ("evaluate_flags",)])
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_numeric_ordering_and_remote_fallback(self, api, _capture, remote):
+        cases = (
+            ("gt", 2, {"amount": "10"}, True, False),
+            ("lt", 30, {"amount": "100"}, False, False),
+            ("gte", "5", {"amount": "10"}, True, False),
+            ("lte", "5", {"amount": "10"}, False, False),
+            ("gt", "5", {"amount": "10px"}, False, False),
+            ("gt", "5", {"amount": None}, False, False),
+            ("gt", "5px", {"amount": "10"}, True, True),
+            ("gt", "5px", {"amount": None}, True, True),
+            ("gt", "5", {}, True, True),
+            ("gt", "2", {"amount": Decimal(10)}, True, False),
+            ("gte", "5", {"amount": Decimal(5)}, True, False),
+            ("lt", "5", {"amount": Decimal(2)}, True, False),
+            ("lte", "5", {"amount": Decimal(5)}, True, False),
+            (
+                "gt",
+                "9007199254740992",
+                {"amount": Decimal(9007199254740993)},
+                False,
+                False,
+            ),
+            ("gte", "0.1", {"amount": Decimal("0.1")}, True, False),
+            ("lte", "0", {"amount": Decimal("1e-400")}, True, False),
+            ("gt", "2", {"amount": Decimal("1e10000")}, False, False),
+            ("gt", "2", {"amount": Decimal("-1e10000")}, False, False),
+            ("gt", "2", {"amount": Decimal("NaN")}, False, False),
+            ("gt", "2", {"amount": Decimal("sNaN")}, False, False),
+            ("gt", "2", {"amount": Decimal("Infinity")}, False, False),
+            ("gt", "2", {"amount": Decimal("-Infinity")}, False, False),
+        )
+        for operator, condition, properties, expected, fallback in cases:
+            for local_only in (False, True):
+                with self.subTest(
+                    operator=operator,
+                    condition=condition,
+                    properties=properties,
+                    local_only=local_only,
+                ):
+                    self.client.feature_flags = [
+                        {
+                            "id": 1,
+                            "key": "numeric-flag",
+                            "active": True,
+                            "filters": {
+                                "groups": [
+                                    {
+                                        "properties": [
+                                            {
+                                                "key": "amount",
+                                                "operator": operator,
+                                                "value": condition,
+                                                "type": "person",
+                                            }
+                                        ],
+                                        "rollout_percentage": 100,
+                                    }
+                                ]
+                            },
+                        }
+                    ]
+                    remote.reset_mock()
+                    remote.return_value = {
+                        "flags": {"numeric-flag": {"enabled": True, "variant": None}}
+                    }
+                    kwargs = {
+                        "person_properties": properties,
+                        "only_evaluate_locally": local_only,
+                    }
+                    if api == "get_feature_flag":
+                        result = self.client.get_feature_flag(
+                            "numeric-flag",
+                            "user-1",
+                            send_feature_flag_events=False,
+                            **kwargs,
+                        )
+                    else:
+                        result = self.client.evaluate_flags(
+                            "user-1", **kwargs
+                        ).get_flag("numeric-flag")
+                    if fallback and local_only:
+                        self.assertIsNone(result)
+                    else:
+                        self.assertIs(result, expected)
+                    self.assertEqual(
+                        remote.call_count, int(fallback and not local_only)
+                    )
+
+
 class TestLocalEvaluation(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -5625,16 +5725,121 @@ def test_match_properties_math_operators(self):
         property_e = self.property(key="key", value="30", operator="lt")
         self.assertTrue(match_property(property_e, {"key": "29"}))
 
-        # depending on the type of override, we adjust type comparison
-        self.assertTrue(match_property(property_e, {"key": "100"}))
+        self.assertFalse(match_property(property_e, {"key": "100"}))
         self.assertFalse(match_property(property_e, {"key": 100}))
 
         property_f = self.property(key="key", value="123aloha", operator="gt")
-        self.assertFalse(match_property(property_f, {"key": "123"}))
-        self.assertFalse(match_property(property_f, {"key": 122}))
+        for actual in ("123", 122, 129):
+            with self.assertRaises(InconclusiveMatchError):
+                match_property(property_f, {"key": actual})
+
+    @parameterized.expand(
+        [
+            ("gt", "10", 2, True),
+            ("lt", "100", 30, False),
+            ("gte", "10", "5", True),
+            ("lte", "10", "5", False),
+            ("gt", "+1.e1", "+.5e+1", True),
+            ("lt", "-1.25E+2", "-12.5", True),
+            ("gte", "-.5", "-5e-1", True),
+            ("lte", "1e-400", 0, True),
+            ("gte", "1.7976931348623157e308", 1e308, True),
+            ("gt", "9007199254740993", "9007199254740992", False),
+            ("gt", 9007199254740993, 9007199254740992, False),
+            ("gt", Decimal(9007199254740993), "9007199254740992", False),
+            ("gte", Decimal("0.1"), "0.1", True),
+            ("lte", Decimal("1e-400"), "0", True),
+        ]
+    )
+    def test_numeric_ordering_regressions(self, operator, actual, condition, expected):
+        for version in (1, 2):
+            with self.subTest(version=version):
+                self.assertEqual(
+                    match_property(
+                        self.property("key", condition, operator),
+                        {"key": actual},
+                        property_matching_version=version,
+                    ),
+                    expected,
+                )
 
-        # this turns into a string comparison
-        self.assertTrue(match_property(property_f, {"key": 129}))
+    def test_numeric_ordering_operand_types_and_boundaries(self):
+        for operator, expected_results in (
+            ("gt", (False, False, True)),
+            ("gte", (False, True, True)),
+            ("lt", (True, False, False)),
+            ("lte", (True, True, False)),
+        ):
+            for condition in (5, 5.0, "5"):
+                prop = self.property("key", condition, operator)
+                for actuals, expected in zip(
+                    (
+                        (2, 2.0, "2", Decimal(2)),
+                        (5, 5.0, "5", Decimal(5)),
+                        (10, 10.0, "10", Decimal(10)),
+                    ),
+                    expected_results,
+                ):
+                    for actual in actuals:
+                        with self.subTest(
+                            operator=operator, condition=condition, actual=actual
+                        ):
+                            self.assertEqual(
+                                match_property(prop, {"key": actual}), expected
+                            )
+
+    def test_numeric_ordering_invalid_operands(self):
+        invalid_values = (
+            "",
+            "abc",
+            "10px",
+            " 10",
+            "10 ",
+            "10\n",
+            "1_0",
+            "1,0",
+            "1e",
+            "0x10",
+            "١٠",
+            "NaN",
+            "Infinity",
+            "-inf",
+            "1e309",
+            float("nan"),
+            float("inf"),
+            float("-inf"),
+            Decimal("1e10000"),
+            Decimal("-1e10000"),
+            Decimal("NaN"),
+            Decimal("sNaN"),
+            Decimal("Infinity"),
+            Decimal("-Infinity"),
+            10**400,
+            True,
+            False,
+            None,
+            [],
+            [10],
+            {},
+            {"value": 10},
+            b"10",
+        )
+        for operator in ("gt", "gte", "lt", "lte"):
+            for invalid in invalid_values:
+                with self.subTest(operator=operator, invalid=invalid):
+                    for condition in (5, "5"):
+                        prop = self.property("key", condition, operator)
+                        self.assertFalse(match_property(prop, {"key": invalid}))
+                    prop = self.property("key", invalid, operator)
+                    for actual in (10, "10", None):
+                        with self.assertRaises(InconclusiveMatchError):
+                            match_property(prop, {"key": actual})
+            for condition in (5, "5"):
+                prop = self.property("key", condition, operator)
+                with self.assertRaises(InconclusiveMatchError):
+                    match_property(prop, {})
+            with self.assertRaises(InconclusiveMatchError):
+                match_property({"key": "key", "operator": operator}, {"key": 10})
 
     def test_match_property_date_operators(self):
         property_a = self.property(
@@ -5889,10 +6094,12 @@ def test_none_property_value_with_all_operators(self):
         self.assertFalse(match_property(property_f, {"key": None}))
 
         property_g = self.property(key="key", value="xyz", operator="gte")
-        self.assertFalse(match_property(property_g, {"key": None}))
+        with self.assertRaises(InconclusiveMatchError):
+            match_property(property_g, {"key": None})
 
         property_h = self.property(key="key", value="Oo", operator="lte")
-        self.assertFalse(match_property(property_h, {"key": None}))
+        with self.assertRaises(InconclusiveMatchError):
+            match_property(property_h, {"key": None})
 
         property_i = self.property(
             key="key", value="2022-05-01", operator="is_date_before"

From cb7580e2b884ca99b0693913fc822d2da1559701 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:59:03 +0000
Subject: [PATCH 056/245] chore: Release v7.73.2 [skip ci]

---
 .sampo/changesets/numeric-string-flag-comparisons.md | 5 -----
 openfeature-provider/CHANGELOG.md                    | 6 ++++++
 openfeature-provider/pyproject.toml                  | 2 +-
 posthog/CHANGELOG.md                                 | 6 ++++++
 posthog/version.py                                   | 2 +-
 pyproject.toml                                       | 2 +-
 uv.lock                                              | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/numeric-string-flag-comparisons.md

diff --git a/.sampo/changesets/numeric-string-flag-comparisons.md b/.sampo/changesets/numeric-string-flag-comparisons.md
deleted file mode 100644
index b544a8ee4..000000000
--- a/.sampo/changesets/numeric-string-flag-comparisons.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Fix local feature flag `gt`, `gte`, `lt`, and `lte` comparisons to compare numeric strings numerically rather than lexicographically. This can change which users match flags targeting numeric-string properties. Only complete, unpadded decimal strings and finite numbers are accepted: invalid properties no longer compare lexicographically, and invalid filter values allow remote evaluation fallback.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 8b582d72a..a38945df1 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.111 — 2026-10-20
+
+### Patch changes
+
+- Updated dependencies: posthog@7.73.2
+
 ## 0.1.110 — 2026-10-20
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 9af61ba49..e722e508c 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.110"
+version = "0.1.111"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 9629faa88..49618a118 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.73.2 — 2026-10-20
+
+### Patch changes
+
+- [63b5dcc](https://github.com/posthog/posthog-python/commit/63b5dcca4ebaf3d42fee4cf6c9639e516dc2df4a) Fix local feature flag `gt`, `gte`, `lt`, and `lte` comparisons to compare numeric strings numerically rather than lexicographically. This can change which users match flags targeting numeric-string properties. Only complete, unpadded decimal strings and finite numbers are accepted: invalid properties no longer compare lexicographically, and invalid filter values allow remote evaluation fallback. — Thanks @dustinbyrne!
+
 ## 7.73.1 — 2026-10-20
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index ab107779f..fecfeedf6 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.73.1"
+VERSION = "7.73.2"
diff --git a/pyproject.toml b/pyproject.toml
index 2c84a22fa..846ad2a2a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.73.1"
+version = "7.73.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 79fe59973..21512f276 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2542,7 +2542,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.110"
+version = "0.1.111"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2872,7 +2872,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.1"
+version = "7.73.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 1222ac7f269b1acc189a5f9284fb74bafdc2f572 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:59:08 +0000
Subject: [PATCH 057/245] Update generated references

---
 .../posthog-python-references-7.73.2.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.73.2.json

diff --git a/references/posthog-python-references-7.73.2.json b/references/posthog-python-references-7.73.2.json
new file mode 100644
index 000000000..0df272044
--- /dev/null
+++ b/references/posthog-python-references-7.73.2.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.73.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 9c588f586..0df272044 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.73.1",
+    "version": "7.73.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From f70b3cc3f0c5054f35ffc974b50005431aea511d Mon Sep 17 00:00:00 2001
From: mosafariuk <mosafariuk@gmail.com>
Date: Wed, 21 Oct 2026 11:00:24 +0100
Subject: [PATCH 058/245] fix(ai): keep the openai.Stream API on sync OpenAI
 streams (#1062)

Sync chat completions and Responses streams returned a bare generator, so
`with`, `close()` and attributes such as `.response` were lost. Wrap them
with _StreamWrapper, as #804 did for Anthropic and #645 did for async.

Co-authored-by: Dustin Byrne <dustin@posthog.com>
---
 .sampo/changesets/openai-sync-stream-api.md |   5 +
 posthog/ai/openai/openai.py                 |   5 +-
 posthog/ai/stream.py                        |   4 +-
 posthog/test/ai/openai/test_openai.py       | 119 +++++++++++++++++++-
 posthog/test/ai/utils.py                    |  23 ++++
 5 files changed, 152 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/openai-sync-stream-api.md

diff --git a/.sampo/changesets/openai-sync-stream-api.md b/.sampo/changesets/openai-sync-stream-api.md
new file mode 100644
index 000000000..8d70d9284
--- /dev/null
+++ b/.sampo/changesets/openai-sync-stream-api.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Keep the `openai.Stream` API on sync OpenAI chat completions and Responses streams, so `with`, `close()` and attributes such as `.response` work as they do without PostHog.
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index c1950939c..ea00a197b 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -33,6 +33,7 @@
     _ResponsesStreamState,
     _build_streaming_event_data,
 )
+from ..stream import _StreamWrapper
 from ._embeddings import _capture_embedding_event
 from .wrapper_utils import (
     _OpenAIWrapperResource,
@@ -185,7 +186,7 @@ def generator():
                     time.time() - start_time,
                 )
 
-        return generator()
+        return _StreamWrapper(generator(), stream=response)
 
     def _capture_streaming_event(
         self,
@@ -403,7 +404,7 @@ def generator():
                     time.time() - start_time,
                 )
 
-        return generator()
+        return _StreamWrapper(generator(), stream=response)
 
     def _capture_streaming_event(
         self,
diff --git a/posthog/ai/stream.py b/posthog/ai/stream.py
index 2499f6e68..8744c6177 100644
--- a/posthog/ai/stream.py
+++ b/posthog/ai/stream.py
@@ -32,7 +32,9 @@ def close(self) -> None:
         try:
             self._generator.close()
         finally:
-            self._stream.close()
+            close = getattr(self._stream, "close", None)
+            if close is not None:
+                close()
 
     def __getattr__(self, name: str) -> Any:
         if name.startswith("_"):
diff --git a/posthog/test/ai/openai/test_openai.py b/posthog/test/ai/openai/test_openai.py
index 0d22f393a..83304a4b1 100644
--- a/posthog/test/ai/openai/test_openai.py
+++ b/posthog/test/ai/openai/test_openai.py
@@ -36,7 +36,11 @@
     from posthog.ai.openai import OpenAI
     from posthog.ai.openai.openai_async import AsyncOpenAI
     from posthog.ai.openai.wrapper_utils import reset_fallback_warnings
-    from posthog.test.ai.utils import RecordingAsyncStream, make_response_usage
+    from posthog.test.ai.utils import (
+        RecordingAsyncStream,
+        RecordingStream,
+        make_response_usage,
+    )
 
     OPENAI_AVAILABLE = True
 except ImportError:
@@ -2403,6 +2407,119 @@ async def mock_create(self, **kwargs):
     assert mock_client.capture.call_count == 1
 
 
+def test_chat_streaming_supports_with_and_proxies_provider_stream(
+    mock_client, streaming_tool_call_chunks
+):
+    """Sync chat completions stream=True must keep the `openai.Stream` API:
+    `with`, and attributes such as `.response`."""
+    source = RecordingStream(streaming_tool_call_chunks)
+
+    with patch(
+        "openai.resources.chat.completions.Completions.create", return_value=source
+    ):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hi"}],
+            stream=True,
+            posthog_distinct_id="test-id",
+        )
+
+        assert response.response == "provider-response"
+        with response as stream:
+            chunks = list(stream)
+
+    assert chunks == streaming_tool_call_chunks
+    assert source.closed is True
+    assert mock_client.capture.call_count == 1
+    call_args = mock_client.capture.call_args[1]
+    props = call_args["properties"]
+    assert call_args["event"] == "$ai_generation"
+    assert props["$ai_provider"] == "openai"
+    assert props["$ai_model"] == "gpt-4"
+
+
+def test_responses_streaming_supports_with_and_proxies_provider_stream(mock_client):
+    """Sync responses stream=True must keep the `openai.Stream` API."""
+    from unittest.mock import MagicMock
+
+    chunk = MagicMock()
+    chunk.type = "response.text.delta"
+    chunk.text = "hello"
+    source = RecordingStream([chunk])
+
+    with patch("openai.resources.responses.Responses.create", return_value=source):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+
+        response = client.responses.create(
+            model="gpt-4o-mini",
+            input=[{"role": "user", "content": "Hi"}],
+            stream=True,
+            posthog_distinct_id="test-id",
+        )
+
+        assert response.response == "provider-response"
+        with response as stream:
+            received = list(stream)
+
+    assert received == [chunk]
+    assert source.closed is True
+    assert mock_client.capture.call_count == 1
+
+
+def test_chat_streaming_early_exit_closes_provider_stream(
+    mock_client, streaming_tool_call_chunks
+):
+    """Breaking out of a sync stream early must close the underlying provider
+    stream (release the HTTP connection) and still capture the event."""
+    source = RecordingStream(streaming_tool_call_chunks)
+
+    with patch(
+        "openai.resources.chat.completions.Completions.create", return_value=source
+    ):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hi"}],
+            stream=True,
+            posthog_distinct_id="test-id",
+        )
+
+        with response as stream:
+            for _ in stream:
+                break
+
+    assert source.closed is True
+    assert mock_client.capture.call_count == 1
+
+
+def test_chat_streaming_close_closes_provider_stream(
+    mock_client, streaming_tool_call_chunks
+):
+    """Calling `close()` mid-stream, outside a `with` block, must close the
+    provider stream and still capture the event."""
+    source = RecordingStream(streaming_tool_call_chunks)
+
+    with patch(
+        "openai.resources.chat.completions.Completions.create", return_value=source
+    ):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hi"}],
+            stream=True,
+            posthog_distinct_id="test-id",
+        )
+        next(response)
+        response.close()
+
+    assert source.closed is True
+    assert mock_client.capture.call_count == 1
+
+
 def test_ai_lane_client_routes_through_capture_ai(mock_client, mock_openai_response):
     mock_client.enable_full_ai_capture = True
     with patch(
diff --git a/posthog/test/ai/utils.py b/posthog/test/ai/utils.py
index e1ad48f7b..9f27c1f38 100644
--- a/posthog/test/ai/utils.py
+++ b/posthog/test/ai/utils.py
@@ -41,6 +41,29 @@ def build(model_cls, known):
     )
 
 
+class RecordingStream:
+    """Mock provider sync stream that is iterable and records when closed.
+
+    Mirrors the real ``openai.Stream``: it supports ``for`` and exposes
+    ``close()`` plus a ``response`` attribute, so tests can assert both
+    iteration and that the underlying stream is closed on context exit.
+    """
+
+    def __init__(self, items):
+        self._items = iter(items)
+        self.closed = False
+        self.response = "provider-response"
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._items)
+
+    def close(self):
+        self.closed = True
+
+
 class RecordingAsyncStream:
     """Mock provider async stream that is iterable and records when closed.
 

From 57d160712e8d01750031c953bea093065d217128 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Wed, 21 Oct 2026 07:43:05 -0400
Subject: [PATCH 059/245] fix(ai): take cumulative Anthropic stream usage from
 message_delta (#1074)

Anthropic's message_delta usage is cumulative. With server tools (web
search, web fetch, code execution) its input and cache counts exceed
message_start's, but the stream accumulator only recorded message_start's
input and cache counts, so streamed generations under-reported input
tokens and cache writes. Keep the larger of the two for each count.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../cumulative-anthropic-stream-usage.md      |  5 ++
 posthog/ai/anthropic/_anthropic_stream.py     | 25 ++++++
 posthog/test/ai/anthropic/test_anthropic.py   | 83 +++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100644 .sampo/changesets/cumulative-anthropic-stream-usage.md

diff --git a/.sampo/changesets/cumulative-anthropic-stream-usage.md b/.sampo/changesets/cumulative-anthropic-stream-usage.md
new file mode 100644
index 000000000..6e06e0513
--- /dev/null
+++ b/.sampo/changesets/cumulative-anthropic-stream-usage.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Streamed Anthropic generations now take the input and cache token counts from the final `message_delta` usage, which is cumulative. With server tools such as web search, those counts grow past the `message_start` values, so streamed calls under-reported input tokens and cache writes.
diff --git a/posthog/ai/anthropic/_anthropic_stream.py b/posthog/ai/anthropic/_anthropic_stream.py
index e08f6f65e..ff3fbe0b8 100644
--- a/posthog/ai/anthropic/_anthropic_stream.py
+++ b/posthog/ai/anthropic/_anthropic_stream.py
@@ -26,9 +26,34 @@ def __init__(self) -> None:
         # web_search_tool_result, ...), so keep a list that lines up with it.
         self._blocks_by_index: List[StreamingContentBlock] = []
 
+    def _apply_cumulative_input_usage(self, usage: Any) -> None:
+        # Usage on message_delta is cumulative. With server tools (web search,
+        # web fetch, code execution) its input and cache counts grow past
+        # message_start's, which is all the per-event merge records for them.
+        # The totals never shrink, so keep the larger value; a field the event
+        # omits leaves message_start's count in place.
+        input_tokens = getattr(usage, "input_tokens", None)
+        if isinstance(input_tokens, int):
+            self.usage_stats["input_tokens"] = max(
+                self.usage_stats.get("input_tokens") or 0, input_tokens
+            )
+        cache_creation = getattr(usage, "cache_creation_input_tokens", None)
+        if isinstance(cache_creation, int):
+            self.usage_stats["cache_creation_input_tokens"] = max(
+                self.usage_stats.get("cache_creation_input_tokens") or 0,
+                cache_creation,
+            )
+        cache_read = getattr(usage, "cache_read_input_tokens", None)
+        if isinstance(cache_read, int):
+            self.usage_stats["cache_read_input_tokens"] = max(
+                self.usage_stats.get("cache_read_input_tokens") or 0, cache_read
+            )
+
     def consume(self, event: Any) -> None:
         event_usage = extract_anthropic_usage_from_event(event)
         merge_usage_stats(self.usage_stats, event_usage)
+        if getattr(event, "type", None) == "message_delta":
+            self._apply_cumulative_input_usage(getattr(event, "usage", None))
 
         if getattr(event, "type", None) == "content_block_start":
             block, tool = handle_anthropic_content_block_start(event)
diff --git a/posthog/test/ai/anthropic/test_anthropic.py b/posthog/test/ai/anthropic/test_anthropic.py
index 84275e9ad..08c66e7e2 100644
--- a/posthog/test/ai/anthropic/test_anthropic.py
+++ b/posthog/test/ai/anthropic/test_anthropic.py
@@ -824,6 +824,89 @@ async def mock_async_create(**kwargs):
     )
 
 
+def anthropic_stream_with_server_tool_usage():
+    # With server tools, message_delta reports cumulative usage that exceeds
+    # message_start's (values from a recorded web search stream).
+    return [
+        RawMessageStartEvent(
+            type="message_start",
+            message=Message(
+                id="msg_1",
+                type="message",
+                role="assistant",
+                model="claude-haiku-4-5",
+                content=[],
+                stop_reason=None,
+                stop_sequence=None,
+                usage=Usage(
+                    input_tokens=2247,
+                    output_tokens=26,
+                    cache_creation_input_tokens=0,
+                    cache_read_input_tokens=0,
+                ),
+            ),
+        ),
+        RawMessageDeltaEvent(
+            type="message_delta",
+            delta=Delta(stop_reason="end_turn", stop_sequence=None),
+            usage=MessageDeltaUsage(
+                input_tokens=2254,
+                output_tokens=110,
+                cache_creation_input_tokens=17269,
+                cache_read_input_tokens=0,
+            ),
+        ),
+        RawMessageStopEvent(type="message_stop"),
+    ]
+
+
+def assert_cumulative_delta_usage(props):
+    assert props["$ai_input_tokens"] == 2254
+    assert props["$ai_output_tokens"] == 110
+    assert props["$ai_cache_creation_input_tokens"] == 17269
+    assert props["$ai_cache_read_input_tokens"] == 0
+
+
+def test_streaming_takes_cumulative_message_delta_usage(mock_client):
+    with patch(
+        "anthropic.resources.Messages.create",
+        return_value=iter(anthropic_stream_with_server_tool_usage()),
+    ):
+        client = Anthropic(api_key="test-key", posthog_client=mock_client)
+        response = client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        list(response)
+
+    assert_cumulative_delta_usage(mock_client.capture.call_args.kwargs["properties"])
+
+
+@pytest.mark.asyncio
+async def test_streaming_takes_cumulative_message_delta_usage_async(mock_client):
+    async def mock_async_stream():
+        for event in anthropic_stream_with_server_tool_usage():
+            yield event
+
+    async def mock_async_create(**kwargs):
+        return mock_async_stream()
+
+    with patch(
+        "anthropic.resources.messages.AsyncMessages.create",
+        side_effect=mock_async_create,
+    ):
+        client = AsyncAnthropic(api_key="test-key", posthog_client=mock_client)
+        response = await client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        [event async for event in response]
+
+    assert_cumulative_delta_usage(mock_client.capture.call_args.kwargs["properties"])
+
+
 def test_anthropic_bedrock_preserves_cache_creation_ttl_breakdown(
     mock_client, mock_anthropic_response_with_cache_ttl
 ):

From 24c6722fb3a6317ea41917400c148ca44f64cc43 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 13:12:55 +0000
Subject: [PATCH 060/245] chore: Release v7.73.3 [skip ci]

---
 .sampo/changesets/cumulative-anthropic-stream-usage.md | 5 -----
 .sampo/changesets/openai-sync-stream-api.md            | 5 -----
 openfeature-provider/CHANGELOG.md                      | 6 ++++++
 openfeature-provider/pyproject.toml                    | 2 +-
 posthog/CHANGELOG.md                                   | 7 +++++++
 posthog/version.py                                     | 2 +-
 pyproject.toml                                         | 2 +-
 uv.lock                                                | 4 ++--
 8 files changed, 18 insertions(+), 15 deletions(-)
 delete mode 100644 .sampo/changesets/cumulative-anthropic-stream-usage.md
 delete mode 100644 .sampo/changesets/openai-sync-stream-api.md

diff --git a/.sampo/changesets/cumulative-anthropic-stream-usage.md b/.sampo/changesets/cumulative-anthropic-stream-usage.md
deleted file mode 100644
index 6e06e0513..000000000
--- a/.sampo/changesets/cumulative-anthropic-stream-usage.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Streamed Anthropic generations now take the input and cache token counts from the final `message_delta` usage, which is cumulative. With server tools such as web search, those counts grow past the `message_start` values, so streamed calls under-reported input tokens and cache writes.
diff --git a/.sampo/changesets/openai-sync-stream-api.md b/.sampo/changesets/openai-sync-stream-api.md
deleted file mode 100644
index 8d70d9284..000000000
--- a/.sampo/changesets/openai-sync-stream-api.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Keep the `openai.Stream` API on sync OpenAI chat completions and Responses streams, so `with`, `close()` and attributes such as `.response` work as they do without PostHog.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index a38945df1..eae14033a 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.112 — 2026-10-21
+
+### Patch changes
+
+- Updated dependencies: posthog@7.73.3
+
 ## 0.1.111 — 2026-10-20
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index e722e508c..89ebd7d48 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.111"
+version = "0.1.112"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 49618a118..ef5cff2d4 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,12 @@
 # posthog
 
+## 7.73.3 — 2026-10-21
+
+### Patch changes
+
+- [57d1607](https://github.com/posthog/posthog-python/commit/57d160712e8d01750031c953bea093065d217128) Streamed Anthropic generations now take the input and cache token counts from the final `message_delta` usage, which is cumulative. With server tools such as web search, those counts grow past the `message_start` values, so streamed calls under-reported input tokens and cache writes. — Thanks @pcbeingused333 for your first contribution 🎉!
+- [f70b3cc](https://github.com/posthog/posthog-python/commit/f70b3cc3f0c5054f35ffc974b50005431aea511d) Keep the `openai.Stream` API on sync OpenAI chat completions and Responses streams, so `with`, `close()` and attributes such as `.response` work as they do without PostHog. — Thanks @mosafariuk for your first contribution 🎉!
+
 ## 7.73.2 — 2026-10-20
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index fecfeedf6..94c1d369b 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.73.2"
+VERSION = "7.73.3"
diff --git a/pyproject.toml b/pyproject.toml
index 846ad2a2a..aa7cc64c1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.73.2"
+version = "7.73.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 21512f276..bed4085a4 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2542,7 +2542,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.111"
+version = "0.1.112"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2872,7 +2872,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.2"
+version = "7.73.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From bf873523c700d9940c8ec86b677d2bd4904dfa55 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 13:13:00 +0000
Subject: [PATCH 061/245] Update generated references

---
 .../posthog-python-references-7.73.3.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.73.3.json

diff --git a/references/posthog-python-references-7.73.3.json b/references/posthog-python-references-7.73.3.json
new file mode 100644
index 000000000..973a24408
--- /dev/null
+++ b/references/posthog-python-references-7.73.3.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.73.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 0df272044..973a24408 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.73.2",
+    "version": "7.73.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b8879a7550e1bc2728bb5d23d8ddb215ba3602a7 Mon Sep 17 00:00:00 2001
From: Radu Raicea <radu@raicea.com>
Date: Wed, 21 Oct 2026 10:38:06 -0400
Subject: [PATCH 062/245] feat(llma): add datasets to offline evaluations
 (#1090)

* feat(llma): add datasets to offline evaluations

* chore(llma): share evaluation request and response helpers

* fix(llma): address dataset sdk review feedback
---
 .sampo/changesets/ai-evaluation-datasets.md   |   5 +
 .../example-offline-evaluations/README.md     | 163 +++-
 examples/example-offline-evaluations/main.py  |  93 +-
 posthog/ai/evaluations/__init__.py            |  24 +-
 posthog/ai/evaluations/_async_datasets.py     | 443 +++++++++
 posthog/ai/evaluations/_client.py             |   9 +-
 .../ai/evaluations/_dataset_serialization.py  | 251 ++++++
 posthog/ai/evaluations/_dataset_types.py      | 111 +++
 posthog/ai/evaluations/_datasets.py           | 436 +++++++++
 posthog/ai/evaluations/_scorers.py            |  52 +-
 posthog/ai/evaluations/_serialization.py      |  49 +-
 posthog/ai/evaluations/_tags.py               |  14 +-
 posthog/ai/evaluations/_types.py              |  40 +
 posthog/test/ai/test_evaluations_datasets.py  | 838 ++++++++++++++++++
 posthog/test/ai/test_evaluations_scorers.py   |  14 +-
 references/public_api_snapshot.txt            | 100 +++
 16 files changed, 2570 insertions(+), 72 deletions(-)
 create mode 100644 .sampo/changesets/ai-evaluation-datasets.md
 create mode 100644 posthog/ai/evaluations/_async_datasets.py
 create mode 100644 posthog/ai/evaluations/_dataset_serialization.py
 create mode 100644 posthog/ai/evaluations/_dataset_types.py
 create mode 100644 posthog/ai/evaluations/_datasets.py
 create mode 100644 posthog/test/ai/test_evaluations_datasets.py

diff --git a/.sampo/changesets/ai-evaluation-datasets.md b/.sampo/changesets/ai-evaluation-datasets.md
new file mode 100644
index 000000000..22d689b31
--- /dev/null
+++ b/.sampo/changesets/ai-evaluation-datasets.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Manage AI observability datasets and items through `OfflineEvaluations.datasets` and `AsyncOfflineEvaluations.datasets`, including history, tags, and archive/restore operations. Pin a dataset snapshot for lazy, consistent reads and use `EvaluationItem.from_dataset_item()` to preserve case provenance across offline experiments and scorers. Item creates with a caller-supplied `client_item_id` support safe retries; updates use explicit version checks.
diff --git a/examples/example-offline-evaluations/README.md b/examples/example-offline-evaluations/README.md
index 279fe4e70..7da7dd1c8 100644
--- a/examples/example-offline-evaluations/README.md
+++ b/examples/example-offline-evaluations/README.md
@@ -1,6 +1,6 @@
 # Offline evaluations
 
-Upload evaluations you have already run, manage reusable scorers, and explicitly finish an experiment. The SDK returns server acknowledgments for every operation. It does not execute your application or judges, create traces, or upload in the background.
+Upload evaluations you have already run, manage reusable scorers and datasets, and explicitly finish an experiment. The SDK returns server acknowledgments for every operation. It does not execute your application or judges, create traces, or upload in the background.
 
 ## Credentials and setup
 
@@ -11,11 +11,15 @@ Offline evaluations must be enabled for your PostHog project. Use the project's
 | Create experiments, upload results, complete/fail | Personal API key or project secret key with `offline_evaluation_ingestion:write` |
 | Fetch scorers and versions | Personal API key with `llm_analytics:read` |
 | Create/update scorers and create versions | Personal API key with `llm_analytics:write` |
+| Fetch datasets, items, and history | Personal API key with `dataset:read` |
+| Create/update/archive/restore datasets and items | Personal API key with `dataset:write` |
 | Read experiment tags | Personal API key with `evaluation:read` |
 | Replace experiment tags | Personal API key with `evaluation:write` |
 
 A personal key can cover both scorer management and uploads. Project secret keys can upload using a known scorer-version UUID without scorer read access. All operations use the explicit project/environment; scorer names are not unique.
 
+Dataset operations also require the datasets feature to be enabled. Dataset reads, scorer reads, and experiment uploads use their own scopes; an upload-only credential cannot fetch a dataset. Keep personal keys in server-side scripts or CI secrets.
+
 From this repository's root:
 
 ```bash
@@ -85,6 +89,163 @@ EvaluationItem(input=None)       # Payload contains a null input.
 
 The client context manager releases connections. Call `complete()` explicitly after uploads succeed, or `fail()` when you deliberately want to close the experiment as failed. Neither exceptions nor async cancellation automatically close an experiment. Expected counts include every outcome status; the server checks them on completion.
 
+## Datasets and reproducible evaluations
+
+Use `evaluations.datasets` to manage PostHog-hosted datasets with the same client configuration as scorers and experiments. Dataset names are unique within a project; keep the returned UUID for subsequent operations.
+
+Provision a dataset once with a personal key that has `dataset:write`:
+
+```python
+dataset = evaluations.datasets.create(
+    name="Capital city regression cases",
+    description="Cases for the offline evaluation example",
+    tags=["regression"],
+)
+case = evaluations.datasets.create_item(
+    dataset.id,
+    client_item_id="capital-france",
+    input="Capital of France?",
+    expected_output="Paris",
+    metadata={"category": "geography"},
+)
+print(dataset.id)
+```
+
+An identical item create with the same `client_item_id` returns the existing active item. Reusing that key with different current content, or for an archived item, raises `EvaluationAPIError` with `code="client_item_id_conflict"`. Choose a stable key per case and retain it across process restarts. Creating the dataset itself is not idempotent; keep its ID instead of provisioning it on each evaluation run.
+
+Pin both the dataset and scorer before running your application:
+
+```python
+from posthog.ai.evaluations import EvaluationItem, OfflineEvaluations
+
+def capital_answer(question):
+    return {"Capital of France?": "Paris", "Capital of Italy?": "Rome"}.get(
+        question, "I don't know"
+    )
+
+with OfflineEvaluations(project_id=123, secret_key=personal_api_key) as evaluations:
+    snapshot = evaluations.datasets.snapshot(dataset_id)  # Resolve latest once.
+    scorer = evaluations.scorers.get(scorer_id)  # A boolean exact-match scorer.
+    version_id = scorer.current_version_id
+    experiment = evaluations.create_experiment(
+        name="Capital city regression",
+        dataset_revision_id=snapshot.revision_id,
+        application_version="your-commit-sha",
+        run_source="ci",
+    )
+
+    for case in snapshot.iter_items():
+        output = capital_answer(case.input)
+        item = EvaluationItem.from_dataset_item(case, output=output)
+        if case.expected_output is None:
+            experiment.upload_result(
+                item=item, scorer_version_id=version_id, status="not_applicable",
+            )
+        else:
+            experiment.upload_result(
+                item=item, scorer_version_id=version_id,
+                value=output == case.expected_output,
+            )
+
+    experiment.complete()
+```
+
+This example uses string inputs. Replace `capital_answer` and the equality check with your own application and judge. The SDK does not run scorer definitions. For multiple scorers, reuse the same `EvaluationItem` and upload one result per scorer-version UUID. For independent trials, call `from_dataset_item` again and pass a distinct `trial`, such as `trial="2"`; each call generates a new execution UUID. The helper defaults `case_key` to `client_item_id`, falling back to the stable dataset item UUID, and accepts an explicit override.
+
+`from_dataset_item` copies input, expected output, metadata, and immutable item provenance. It never uses `source_output` as a new execution's output or expected answer, and never uses the original source trace as the new application's trace. Pass `application_trace_id` explicitly for the new execution. Omit `output` if execution failed before producing one, then upload an error outcome. Omitted output differs from `output=None`.
+
+### Snapshot and pagination behavior
+
+- `snapshot(dataset_id, revision=12)` selects a historical **number**. The returned `revision_id` is the **UUID** to pass to `create_experiment`. The backend derives the remaining hosted-dataset identifiers from that UUID.
+- Every item request uses the pinned revision, even if another process edits or archives items during iteration. `DatasetItem.dataset_revision_id` identifies the revision that introduced that item version; it can differ from the snapshot's revision ID. Do not use it as the experiment's revision.
+- `snapshot()` fetches metadata only. `snapshot.iter_items(page_size=25)` lazily fetches active items, one page at a time. Keep the client open. Repeating iteration starts again at the first page without caching; read errors propagate rather than silently returning a partial dataset.
+- A new dataset has no revision until its first item is added, so `snapshot()` raises `ValueError`. An existing revision with zero active items yields an empty iterator. Archived datasets remain readable.
+- `snapshot.dataset` contains current descriptive metadata observed when the snapshot was resolved. Names, descriptions, tags, and dataset metadata are not historical item content.
+
+For explicit paging, each `list*` method returns typed `results`, `count`, and `next_offset`. Continue with the same filters until `next_offset is None`. Dataset/revision pages allow at most 100 entries, item pages 25, and item-history pages 100. `list_items` without a revision reads live state on each request; use a snapshot for an evaluation run. A historical snapshot may make multiple metadata requests to find its revision UUID.
+
+| Method | Purpose |
+| --- | --- |
+| `list(search=..., tags=..., tag_match="any", archived=False, order_by="-created_at")` | Find datasets; `archived=True` selects archived datasets only |
+| `get(dataset_id)` | Read current dataset metadata and revision references |
+| `create(name=..., description=..., metadata=..., tags=...)` | Create an empty dataset |
+| `update(dataset_id, name=..., description=..., metadata=..., tags=...)` | Replace supplied metadata fields without creating an item revision |
+| `archive(dataset_id)` / `restore(dataset_id)` | Change dataset archive state; restore leaves individual item states unchanged |
+| `list_revisions(dataset_id)` | Read revision history, newest first |
+| `list_items(dataset_id, revision=..., archived=False)` | Read one page of current or historical items |
+| `get_item(item_id, revision=...)` | Read one stable item at the current or selected dataset revision |
+| `create_item(dataset_id, input=..., ...)` | Add a case and its first version |
+| `update_item(item_id, base_version=..., input=..., expected_output=..., metadata=...)` | Update editable content with optimistic concurrency |
+| `archive_item(item_id, base_version=...)` | Archive an active item with a new version |
+| `restore_item(item_id, base_version=..., source_version=...)` | Restore an archived item, optionally copying a historical item version |
+| `list_item_versions(item_id)` | Read item history, newest first |
+
+Dataset and item metadata are JSON objects. Inputs accept any non-null JSON value; expected/source outputs can be null. Writes require finite numbers, JSON string keys, and at most 32 nested containers. The server enforces dataset, item, version, and payload size limits; failures retain their codes and details in `EvaluationAPIError`. JSON values returned by reads are local copies. Editing them does not write to PostHog.
+
+To save source provenance on creation, supply `source_trace_id` together with a timezone-aware `source_timestamp`; optionally add `source_event_id`. Source fields and `client_item_id` cannot be edited later.
+
+### Updates and recovery
+
+```python
+case = evaluations.datasets.get_item(item_id)
+updated = evaluations.datasets.update_item(
+    case.id,
+    base_version=case.version,
+    expected_output=None,  # Clear the answer; omitting it preserves it.
+    metadata={},          # Clear metadata; omitting it preserves it.
+)
+```
+
+Pass the **observed item version number** as `base_version` for updates, archive, and restore. A stale version raises a 409 `stale_version` conflict with details in `error.response`, including `current_version`. The SDK does not fetch a newer version and overwrite it automatically. Changed content creates a version and dataset revision; identical content is a no-op. Dataset descriptions clear with `""`, metadata with `{}`, and tags with `[]`; those fields do not accept `None`.
+
+Reads retry within the configured transport limits. Item creates retry only when you supply a `client_item_id`. Other mutations never retry automatically. After an unknown write outcome, inspect the current state before issuing another mutation. Dataset errors use the same `EvaluationAPIError` as scorer and experiment operations, including `status`, `code`, `response`, and `persistence`.
+
+Run the supplied example against the provisioned dataset:
+
+```bash
+uv run python examples/example-offline-evaluations/main.py \
+  --dataset-id '<dataset-uuid>' --state dataset-run.json
+
+# Optional: select an earlier numeric revision for a new run.
+uv run python examples/example-offline-evaluations/main.py \
+  --dataset-id '<dataset-uuid>' --dataset-revision 1 --state historical-run.json
+```
+
+The example prepares and saves the pinned revision, execution identities, scorer version, and results **before the first experiment write**. If the state file already exists, replay uses that file without fetching a newer dataset, selecting another scorer version, or running the application again. Dataset selection arguments apply only when preparing a new state file. Choose a new file for a new run. This small example materializes its results; for larger workloads, use caller-sized batches and persist each prepared batch before upload.
+
+### Async datasets
+
+Await management methods and snapshot creation. Use `async for` on `iter_items()`; iteration itself is an async iterator, not an awaitable list.
+
+```python
+from posthog.ai.evaluations import AsyncOfflineEvaluations, EvaluationItem
+
+async with AsyncOfflineEvaluations(
+    project_id=123, secret_key=personal_api_key,
+) as evaluations:
+    snapshot = await evaluations.datasets.snapshot(dataset_id)
+    scorer = await evaluations.scorers.get(scorer_id)
+    experiment = await evaluations.create_experiment(
+        name="Async regression", dataset_revision_id=snapshot.revision_id,
+    )
+    async for case in snapshot.iter_items():
+        output = capital_answer(case.input)
+        item = EvaluationItem.from_dataset_item(case, output=output)
+        if case.expected_output is None:
+            await experiment.upload_result(
+                item=item, scorer_version_id=scorer.current_version_id,
+                status="not_applicable",
+            )
+        else:
+            await experiment.upload_result(
+                item=item, scorer_version_id=scorer.current_version_id,
+                value=output == case.expected_output,
+            )
+    await experiment.complete()
+```
+
+Install `posthog[async]` for async support. Cancellation propagates and does not automatically complete or fail an experiment.
+
 ## Typed scorer configuration and polarity
 
 Configurations are public `TypedDict` types: editors suggest fields and type checkers connect `create(kind=...)` to the correct configuration. They are ordinary dictionaries at runtime; server validation remains authoritative.
diff --git a/examples/example-offline-evaluations/main.py b/examples/example-offline-evaluations/main.py
index a3c34171d..6c2e7826f 100644
--- a/examples/example-offline-evaluations/main.py
+++ b/examples/example-offline-evaluations/main.py
@@ -14,6 +14,7 @@
     EvaluationAPIError,
     EvaluationItem,
     EvaluationResult,
+    JSONValue,
     OfflineEvaluations,
 )
 
@@ -33,8 +34,39 @@ def resolve_version(evaluations: OfflineEvaluations) -> str:
     return scorer.current_version_id
 
 
+def capital_answer(input: JSONValue) -> str:
+    """A deterministic application to replace with your own model or agent."""
+    if not isinstance(input, str):
+        raise ValueError("The capital-city example expects string dataset inputs.")
+    return {"Capital of France?": "Paris", "Capital of Italy?": "Milan"}.get(
+        input, "I don't know"
+    )
+
+
+def exact_match_result(item: EvaluationItem, version_id: str) -> EvaluationResult:
+    payload = item.to_dict()["payload"]
+    if payload.get("expected_output") is None:
+        return EvaluationResult(
+            item=item,
+            scorer_version_id=version_id,
+            status="not_applicable",
+            reasoning="This case has no expected answer.",
+        )
+    return EvaluationResult(
+        item=item,
+        scorer_version_id=version_id,
+        value=payload["output"] == payload["expected_output"],
+        reasoning="Exact string comparison",
+    )
+
+
 def prepare_state(
-    evaluations: OfflineEvaluations, project_id: int, host: str
+    evaluations: OfflineEvaluations,
+    project_id: int,
+    host: str,
+    *,
+    dataset_id: str | None = None,
+    dataset_revision: int | None = None,
 ) -> dict[str, Any]:
     version_id = resolve_version(evaluations)
     cases = [
@@ -51,24 +83,24 @@ def prepare_state(
             "expected": "Rome",
         },
     ]
-    items = [
-        EvaluationItem(
-            case_key=case["key"],
-            input=case["input"],
-            output=case["output"],
-            expected_output=case["expected"],
-        )
-        for case in cases
-    ]
-    results = [
-        EvaluationResult(
-            item=item,
-            scorer_version_id=version_id,
-            value=case["output"] == case["expected"],
-            reasoning="Exact string comparison",
-        )
-        for item, case in zip(items, cases)
-    ]
+    snapshot = None
+    if dataset_id is not None:
+        snapshot = evaluations.datasets.snapshot(dataset_id, revision=dataset_revision)
+        items = [
+            EvaluationItem.from_dataset_item(case, output=capital_answer(case.input))
+            for case in snapshot.iter_items()
+        ]
+    else:
+        items = [
+            EvaluationItem(
+                case_key=case["key"],
+                input=case["input"],
+                output=case["output"],
+                expected_output=case["expected"],
+            )
+            for case in cases
+        ]
+    results = [exact_match_result(item, version_id) for item in items]
     return {
         "project_id": project_id,
         "host": host,
@@ -79,6 +111,11 @@ def prepare_state(
             "run_source": "local",
             "expected_item_count": len(items),
             "expected_result_count": len(results),
+            **(
+                {"dataset_revision_id": snapshot.revision_id}
+                if snapshot is not None
+                else {}
+            ),
         },
         "items": [item.to_dict() for item in items],
         "results": [result.to_dict() for result in results],
@@ -108,7 +145,17 @@ def main() -> None:
         default=Path("offline-evaluation-state.json"),
         help="Create a new prepared run here, or replay the existing run exactly.",
     )
+    parser.add_argument(
+        "--dataset-id", help="Run the capital-city application on a PostHog dataset."
+    )
+    parser.add_argument(
+        "--dataset-revision",
+        type=int,
+        help="Pin this numeric revision; defaults to latest once.",
+    )
     args = parser.parse_args()
+    if args.dataset_revision is not None and args.dataset_id is None:
+        parser.error("--dataset-revision requires --dataset-id")
     project_id = int(os.environ["POSTHOG_PROJECT_ID"])
     host = os.environ.get("POSTHOG_HOST", "https://us.posthog.com")
     with OfflineEvaluations(
@@ -133,7 +180,13 @@ def main() -> None:
                     "The saved run belongs to a different project or host."
                 )
         else:
-            state = prepare_state(evaluations, project_id, host)
+            state = prepare_state(
+                evaluations,
+                project_id,
+                host,
+                dataset_id=args.dataset_id,
+                dataset_revision=args.dataset_revision,
+            )
             save_state(args.state, state)
 
         items = {item["id"]: EvaluationItem.from_dict(item) for item in state["items"]}
diff --git a/posthog/ai/evaluations/__init__.py b/posthog/ai/evaluations/__init__.py
index 7d3e89b0d..2dbd0cc35 100644
--- a/posthog/ai/evaluations/__init__.py
+++ b/posthog/ai/evaluations/__init__.py
@@ -1,4 +1,4 @@
-"""Typed offline evaluation uploads, experiment lifecycle, and scorer management.
+"""Typed offline evaluation uploads, experiments, scorers, and dataset management.
 
 from posthog.ai.evaluations import OfflineEvaluations, EvaluationItem
 
@@ -10,6 +10,17 @@
     # experiment.complete()
 """
 
+from ._async_datasets import AsyncDatasets, AsyncDatasetSnapshot
+from ._dataset_types import (
+    Dataset,
+    DatasetItem,
+    DatasetItemPage,
+    DatasetOrder,
+    DatasetPage,
+    DatasetRevision,
+    DatasetRevisionPage,
+)
+from ._datasets import Datasets, DatasetSnapshot
 from ._client import (
     AsyncExperiment,
     AsyncOfflineEvaluations,
@@ -51,6 +62,8 @@
 )
 
 __all__ = [
+    "AsyncDatasets",
+    "AsyncDatasetSnapshot",
     "AsyncExperiment",
     "AsyncOfflineEvaluations",
     "AsyncScorers",
@@ -60,6 +73,15 @@
     "CategoricalPassingRule",
     "CategoricalScorerConfig",
     "CategoricalScorerOption",
+    "Dataset",
+    "DatasetItem",
+    "DatasetItemPage",
+    "DatasetOrder",
+    "DatasetPage",
+    "DatasetRevision",
+    "DatasetRevisionPage",
+    "Datasets",
+    "DatasetSnapshot",
     "EvaluationAPIError",
     "EvaluationItem",
     "EvaluationResult",
diff --git a/posthog/ai/evaluations/_async_datasets.py b/posthog/ai/evaluations/_async_datasets.py
new file mode 100644
index 000000000..80cc6418c
--- /dev/null
+++ b/posthog/ai/evaluations/_async_datasets.py
@@ -0,0 +1,443 @@
+"""Asynchronous dataset management and revision-pinned iteration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import AsyncIterator, Literal, Sequence
+from uuid import UUID
+
+from ._dataset_serialization import (
+    _body,
+    _create_item_body,
+    _dataset,
+    _item,
+    _item_list_params,
+    _list_params,
+    _page,
+    _page_params,
+    _parse,
+    _revision,
+)
+from ._dataset_types import (
+    Dataset,
+    DatasetItem,
+    DatasetItemPage,
+    DatasetOrder,
+    DatasetPage,
+    DatasetRevisionPage,
+)
+from ._serialization import (
+    JSONValue,
+    _UNSET,
+    _Unset,
+    _integer,
+    _uuid,
+)
+from ._transport import AsyncTransport
+
+
+class AsyncDatasets:
+    """Manage datasets through ``AsyncOfflineEvaluations.datasets``.
+
+    Requires a personal key with ``dataset:read`` or ``dataset:write`` and the
+    datasets feature enabled. Mutations return after acknowledgment; only item
+    creates with a caller-supplied ``client_item_id`` are automatically retried.
+    Other lost write responses require inspecting state before retrying.
+    """
+
+    def __init__(self, transport: AsyncTransport, project_id: int) -> None:
+        self._transport = transport
+        self._project_id = project_id
+        self._base = f"/api/projects/{project_id}/datasets/"
+        self._items = f"/api/projects/{project_id}/dataset_items/"
+
+    async def create(
+        self,
+        *,
+        name: str,
+        description: str | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        tags: Sequence[str] | _Unset = _UNSET,
+    ) -> Dataset:
+        """Create an empty dataset. Names must be unique within the project.
+
+        No revision exists until the first item is created. This operation is
+        not automatically retried, including after an ambiguous acknowledgment.
+        """
+        return _parse(
+            lambda data: _dataset(data, self._project_id),
+            await self._transport.request(
+                "POST",
+                self._base,
+                body=_body(
+                    dict(
+                        name=name, description=description, metadata=metadata, tags=tags
+                    )
+                ),
+                retry_safe=False,
+            ),
+        )
+
+    async def get(self, dataset_id: str | UUID) -> Dataset:
+        """Fetch current metadata, including both current revision identifiers."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            await self._transport.request("GET", f"{self._base}{identity}/"),
+        )
+
+    async def list(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
+        archived: bool = False,
+        order_by: DatasetOrder = "-created_at",
+        tags: Sequence[str] | None = None,
+        tag_match: Literal["any", "all"] = "any",
+    ) -> DatasetPage:
+        """Fetch one page of active datasets, or archived datasets if requested.
+
+        Search matches names, descriptions, and metadata. Keep filters and pass
+        ``next_offset`` to continue. Maximum limit is 100; tags accept 20 names.
+        """
+        params = _list_params(
+            limit, offset, search, archived, order_by, tags, tag_match
+        )
+        return _parse(
+            lambda data: DatasetPage(
+                *_page(data, lambda row: _dataset(row, self._project_id), offset)
+            ),
+            await self._transport.request("GET", self._base, params=params),
+        )
+
+    async def update(
+        self,
+        dataset_id: str | UUID,
+        *,
+        name: str | _Unset = _UNSET,
+        description: str | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        tags: Sequence[str] | _Unset = _UNSET,
+    ) -> Dataset:
+        """Replace supplied metadata fields; omitted fields remain unchanged.
+
+        Use description="", metadata={}, or tags=[] to clear them. Metadata
+        updates do not create revisions. Use archive/restore for archive state.
+        """
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            await self._transport.request(
+                "PATCH",
+                f"{self._base}{identity}/",
+                body=_body(
+                    dict(
+                        name=name, description=description, metadata=metadata, tags=tags
+                    )
+                ),
+                retry_safe=False,
+            ),
+        )
+
+    async def archive(self, dataset_id: str | UUID) -> Dataset:
+        """Archive a dataset. It stays readable but rejects item mutations."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            await self._transport.request(
+                "POST", f"{self._base}{identity}/archive/", body=b"{}", retry_safe=False
+            ),
+        )
+
+    async def restore(self, dataset_id: str | UUID) -> Dataset:
+        """Restore an archived dataset without changing individual item states."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            await self._transport.request(
+                "POST", f"{self._base}{identity}/restore/", body=b"{}", retry_safe=False
+            ),
+        )
+
+    async def list_revisions(
+        self, dataset_id: str | UUID, *, limit: int = 50, offset: int = 0
+    ) -> DatasetRevisionPage:
+        """List immutable revisions newest first. Maximum page limit is 100."""
+        identity = _uuid(dataset_id)
+        params = _page_params(limit, offset, 100)
+        return _parse(
+            lambda data: DatasetRevisionPage(
+                *_page(
+                    data, lambda row: _revision(row, self._project_id, identity), offset
+                )
+            ),
+            await self._transport.request(
+                "GET", f"{self._base}{identity}/revisions/", params=params
+            ),
+        )
+
+    async def list_items(
+        self,
+        dataset_id: str | UUID,
+        *,
+        revision: int | None = None,
+        archived: bool = False,
+        limit: int = 25,
+        offset: int = 0,
+    ) -> DatasetItemPage:
+        """Fetch one item page, optionally at an exact numeric dataset revision.
+
+        Omitted revision reads current state for this request. Use ``snapshot``
+        for consistent multi-page evaluation reads. Archived items are excluded
+        by default; archived=True selects only archived items. Maximum limit is 25.
+        """
+        identity = _uuid(dataset_id)
+        params = _item_list_params(identity, revision, archived, limit, offset)
+        return _parse(
+            lambda data: DatasetItemPage(
+                *_page(
+                    data,
+                    lambda row: _item(
+                        row,
+                        self._project_id,
+                        dataset_id=identity,
+                        revision=revision,
+                        archived=archived,
+                    ),
+                    offset,
+                )
+            ),
+            await self._transport.request("GET", self._items, params=params),
+        )
+
+    async def get_item(
+        self, item_id: str | UUID, *, revision: int | None = None
+    ) -> DatasetItem:
+        """Fetch an item by stable UUID, optionally at a dataset revision number."""
+        identity = _uuid(item_id)
+        params: dict[str, str | int] = (
+            {} if revision is None else {"revision": _integer(revision)}
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, revision=revision),
+            await self._transport.request(
+                "GET", f"{self._items}{identity}/", params=params
+            ),
+        )
+
+    async def create_item(
+        self,
+        dataset_id: str | UUID,
+        *,
+        input: JSONValue,
+        expected_output: JSONValue | _Unset = _UNSET,
+        source_output: JSONValue | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        client_item_id: str | None = None,
+        source_trace_id: str | None = None,
+        source_event_id: str | None = None,
+        source_timestamp: datetime | str | None = None,
+    ) -> DatasetItem:
+        """Add a case, creating its first version and a dataset revision.
+
+        ``input`` accepts any non-null JSON value. Supply a stable, case-sensitive
+        ``client_item_id`` to make identical creates retryable across processes.
+        A matching key with different current content or an archived item raises
+        a conflict. Source trace ID and timestamp must be supplied together;
+        source event ID additionally identifies an event within that trace.
+        """
+        identity = _uuid(dataset_id)
+        body = _create_item_body(
+            identity,
+            input=input,
+            expected_output=expected_output,
+            source_output=source_output,
+            metadata=metadata,
+            client_item_id=client_item_id,
+            source_trace_id=source_trace_id,
+            source_event_id=source_event_id,
+            source_timestamp=source_timestamp,
+        )
+        return _parse(
+            lambda data: _item(
+                data, self._project_id, dataset_id=identity, archived=False
+            ),
+            await self._transport.request(
+                "POST", self._items, body=body, retry_safe=client_item_id is not None
+            ),
+        )
+
+    async def update_item(
+        self,
+        item_id: str | UUID,
+        *,
+        base_version: int,
+        input: JSONValue | _Unset = _UNSET,
+        expected_output: JSONValue | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+    ) -> DatasetItem:
+        """Update editable content using the observed item ``version``.
+
+        Changed content creates a version and dataset revision; identical content
+        is a no-op. Omit fields to preserve them, use expected_output=None to clear
+        the answer, or metadata={} to clear metadata. Source fields are immutable.
+        Stale versions raise a conflict without automatic refresh or retry.
+        """
+        identity = _uuid(item_id)
+        body = _body(
+            dict(
+                base_version=_integer(base_version),
+                input=input,
+                expected_output=expected_output,
+                metadata=metadata,
+            )
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=False),
+            await self._transport.request(
+                "PATCH", f"{self._items}{identity}/", body=body, retry_safe=False
+            ),
+        )
+
+    async def archive_item(
+        self, item_id: str | UUID, *, base_version: int
+    ) -> DatasetItem:
+        """Archive an active item by creating a version; require its observed version."""
+        identity = _uuid(item_id)
+        body = _body(dict(base_version=_integer(base_version)))
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=True),
+            await self._transport.request(
+                "POST", f"{self._items}{identity}/archive/", body=body, retry_safe=False
+            ),
+        )
+
+    async def restore_item(
+        self,
+        item_id: str | UUID,
+        *,
+        base_version: int,
+        source_version: int | None = None,
+    ) -> DatasetItem:
+        """Restore an archived item, optionally copying a historical item version.
+
+        ``base_version`` is the observed current version, even when copying an
+        older ``source_version``. Restoration creates a new immutable version.
+        """
+        identity = _uuid(item_id)
+        body = _body(
+            dict(
+                base_version=_integer(base_version),
+                source_version=None
+                if source_version is None
+                else _integer(source_version),
+            )
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=False),
+            await self._transport.request(
+                "POST", f"{self._items}{identity}/restore/", body=body, retry_safe=False
+            ),
+        )
+
+    async def list_item_versions(
+        self, item_id: str | UUID, *, limit: int = 25, offset: int = 0
+    ) -> DatasetItemPage:
+        """List every item version, newest first. Maximum page limit is 100."""
+        identity = _uuid(item_id)
+        params = _page_params(limit, offset, 100)
+        return _parse(
+            lambda data: DatasetItemPage(
+                *_page(
+                    data, lambda row: _item(row, self._project_id, id=identity), offset
+                )
+            ),
+            await self._transport.request(
+                "GET", f"{self._items}{identity}/versions/", params=params
+            ),
+        )
+
+    async def snapshot(
+        self, dataset_id: str | UUID, *, revision: int | None = None
+    ) -> AsyncDatasetSnapshot:
+        """Pin a revision now; item iteration subsequently fetches that exact revision.
+
+        Omit revision to resolve latest once. Historical revisions are resolved
+        through paginated revision metadata. No items are fetched here. Raises
+        ValueError for a never-populated dataset or a nonexistent revision.
+        Keep the owning client open while iterating the returned snapshot.
+        """
+        if revision is not None:
+            _integer(revision)
+        dataset = await self.get(dataset_id)
+        selected = dataset.current_revision if revision is None else revision
+        if selected is None:
+            raise ValueError(
+                "This dataset has no revision. Add an item before taking a snapshot."
+            )
+        if dataset.current_revision is None or selected > dataset.current_revision:
+            raise ValueError(f"Dataset revision {selected} does not exist.")
+        if (
+            selected == dataset.current_revision
+            and dataset.current_revision_id is not None
+        ):
+            return AsyncDatasetSnapshot(
+                dataset, selected, dataset.current_revision_id, self
+            )
+        # Revisions are consecutive and newest first. Concurrent writes can
+        # shift their offsets, so verify the result and scan on a miss.
+        page = await self.list_revisions(
+            dataset.id, limit=1, offset=dataset.current_revision - selected
+        )
+        for candidate in page.results:
+            if candidate.revision == selected:
+                return AsyncDatasetSnapshot(dataset, selected, candidate.id, self)
+        offset = 0
+        while True:
+            page = await self.list_revisions(dataset.id, limit=100, offset=offset)
+            for candidate in page.results:
+                if candidate.revision == selected:
+                    return AsyncDatasetSnapshot(dataset, selected, candidate.id, self)
+            if page.next_offset is None or (
+                page.results and page.results[-1].revision < selected
+            ):
+                raise ValueError(f"Dataset revision {selected} does not exist.")
+            offset = page.next_offset
+
+
+@dataclass(frozen=True)
+class AsyncDatasetSnapshot:
+    """A revision-pinned read handle owned by an open AsyncOfflineEvaluations client.
+
+    ``dataset`` is metadata observed when resolving the snapshot; descriptive
+    metadata is not historically versioned. Use ``revision_id`` when creating
+    an experiment, not the introducing revision on an individual DatasetItem.
+    Repeated iteration fetches the same active item versions without caching.
+    """
+
+    dataset: Dataset
+    revision: int
+    revision_id: str
+    _datasets: AsyncDatasets = field(repr=False, compare=False)
+
+    async def iter_items(self, *, page_size: int = 25) -> AsyncIterator[DatasetItem]:
+        """Use async for to fetch active items at this revision, at most 25 per request.
+
+        Each iteration starts at the first page. Memory is bounded by one page;
+        fetch failures propagate so callers cannot mistake a partial read for a
+        complete dataset. An existing revision with no active items yields none.
+        """
+        _page_params(page_size, 0, 25)
+        offset = 0
+        while True:
+            page = await self._datasets.list_items(
+                self.dataset.id, revision=self.revision, limit=page_size, offset=offset
+            )
+            for item in page.results:
+                yield item
+            if page.next_offset is None:
+                return
+            offset = page.next_offset
diff --git a/posthog/ai/evaluations/_client.py b/posthog/ai/evaluations/_client.py
index 69fc622cb..db0a5d695 100644
--- a/posthog/ai/evaluations/_client.py
+++ b/posthog/ai/evaluations/_client.py
@@ -11,6 +11,8 @@
 
 from typing_extensions import Unpack
 
+from ._async_datasets import AsyncDatasets
+from ._datasets import Datasets
 from ._errors import EvaluationAPIError
 from ._scorers import AsyncScorers, Scorers
 from ._serialization import (
@@ -402,11 +404,12 @@ async def fail(self) -> ExperimentReceipt:
 
 
 class OfflineEvaluations:
-    """Upload offline evaluations and manage scorers in one project/environment.
+    """Upload offline evaluations and manage scorers and datasets in one project.
 
     ``secret_key`` accepts personal or project secret keys with
     offline_evaluation_ingestion:write. Scorer reads/writes require a personal
-    key with llm_analytics:read/write. The offline feature must be enabled.
+    key with llm_analytics:read/write; datasets require dataset:read/write.
+    Each operation requires its corresponding product feature to be enabled.
     ``host`` defaults to the US app API; known ingestion hosts are mapped to
     their app hosts. Custom hosts are preserved. Requests use a 15 second
     timeout and at most three retries by default. Scorer creation/version bumps
@@ -427,6 +430,7 @@ def __init__(
         )
         self._project_id = project_id
         self.scorers = Scorers(self._transport, project_id)
+        self.datasets = Datasets(self._transport, project_id)
         self._path = f"/api/projects/{project_id}/ai_observability/offline_experiments/"
 
     def create_experiment(
@@ -501,6 +505,7 @@ def __init__(
         )
         self._project_id = project_id
         self.scorers = AsyncScorers(self._transport, project_id)
+        self.datasets = AsyncDatasets(self._transport, project_id)
         self._path = f"/api/projects/{project_id}/ai_observability/offline_experiments/"
 
     async def create_experiment(
diff --git a/posthog/ai/evaluations/_dataset_serialization.py b/posthog/ai/evaluations/_dataset_serialization.py
new file mode 100644
index 000000000..c95fb5aea
--- /dev/null
+++ b/posthog/ai/evaluations/_dataset_serialization.py
@@ -0,0 +1,251 @@
+"""Dataset wire validation shared by the synchronous and asynchronous clients."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, Callable, Sequence, TypeVar, cast
+
+from ._dataset_types import Dataset, DatasetItem, DatasetOrder, DatasetRevision
+from ._serialization import (
+    JSONValue,
+    _Unset,
+    _boolean,
+    _date,
+    _encode,
+    _identifier,
+    _integer,
+    _next_offset,
+    _object,
+    _parse_response,
+    _text,
+    _timestamp,
+    _uuid,
+    _validate_json,
+)
+from ._tags import _response_tags, _tag_names, _tag_params
+
+_T = TypeVar("_T")
+
+
+def _json(value: Any) -> JSONValue:
+    return cast(JSONValue, json.loads(_encode(value, sort_keys=False)))
+
+
+def _metadata(value: Any) -> dict[str, JSONValue]:
+    return cast(dict[str, JSONValue], _json(_object(value)))
+
+
+def _user(value: Any) -> dict[str, Any] | None:
+    return None if value is None else _metadata(value)
+
+
+def _owner(data: dict[str, Any], project_id: int) -> int:
+    if _integer(data["team_id"]) != project_id:
+        raise ValueError("The dataset response belongs to another project.")
+    return project_id
+
+
+def _dataset(data: dict[str, Any], project_id: int, id: str | None = None) -> Dataset:
+    identity = _uuid(data["id"])
+    if id is not None and identity != id:
+        raise ValueError("Mismatched dataset ID.")
+    revision = data["current_revision"]
+    revision_id = data["current_revision_id"]
+    if (revision is None) != (revision_id is None):
+        raise ValueError("Incomplete dataset revision reference.")
+    return Dataset(
+        id=identity,
+        name=_text(data["name"]),
+        description=_text(data["description"]),
+        metadata=_metadata(data["metadata"]),
+        tags=_response_tags(data.get("tags", [])),
+        archived=_boolean(data["archived"]),
+        current_revision=None if revision is None else _integer(revision),
+        current_revision_id=None if revision_id is None else _uuid(revision_id),
+        created_at=_date(data["created_at"]),
+        updated_at=None if data["updated_at"] is None else _date(data["updated_at"]),
+        created_by=_user(data["created_by"]),
+        team_id=_owner(data, project_id),
+    )
+
+
+def _revision(
+    data: dict[str, Any], project_id: int, dataset_id: str
+) -> DatasetRevision:
+    if _uuid(data["dataset_id"]) != dataset_id:
+        raise ValueError("Mismatched revision dataset ID.")
+    return DatasetRevision(
+        id=_uuid(data["id"]),
+        dataset_id=dataset_id,
+        revision=_integer(data["revision"]),
+        created_at=_date(data["created_at"]),
+        created_by=_user(data["created_by"]),
+        team_id=_owner(data, project_id),
+    )
+
+
+def _item(
+    data: dict[str, Any],
+    project_id: int,
+    *,
+    id: str | None = None,
+    dataset_id: str | None = None,
+    revision: int | None = None,
+    archived: bool | None = None,
+) -> DatasetItem:
+    identity, owner = _uuid(data["id"]), _uuid(data["dataset"])
+    introduced = _integer(data["dataset_revision"])
+    is_archived = _boolean(data["archived"])
+    if (id is not None and identity != id) or (
+        dataset_id is not None and owner != dataset_id
+    ):
+        raise ValueError("Mismatched dataset item identity.")
+    if revision is not None and introduced > revision:
+        raise ValueError("The item version is newer than the requested revision.")
+    if archived is not None and is_archived != archived:
+        raise ValueError("The item does not match the requested archive filter.")
+    if data["input"] is None:
+        raise ValueError("Dataset inputs cannot be null.")
+    return DatasetItem(
+        id=identity,
+        dataset_id=owner,
+        client_item_id=_identifier(data["client_item_id"], "client_item_id"),
+        version=_integer(data["version"]),
+        version_id=_uuid(data["version_id"]),
+        dataset_revision=introduced,
+        dataset_revision_id=_uuid(data["dataset_revision_id"]),
+        archived=is_archived,
+        input=_json(data["input"]),
+        expected_output=_json(data["expected_output"]),
+        source_output=_json(data["source_output"]),
+        metadata=_metadata(data["metadata"]),
+        source_trace_id=_identifier(data["source_trace_id"], "source_trace_id"),
+        source_event_id=_identifier(data["source_event_id"], "source_event_id"),
+        source_timestamp=None
+        if data["source_timestamp"] is None
+        else _date(data["source_timestamp"]),
+        created_at=_date(data["created_at"]),
+        updated_at=None if data["updated_at"] is None else _date(data["updated_at"]),
+        created_by=_user(data["created_by"]),
+        version_created_at=_date(data["version_created_at"]),
+        version_created_by=_user(data["version_created_by"]),
+        team_id=_owner(data, project_id),
+    )
+
+
+def _parse(parser: Callable[[dict[str, Any]], _T], data: dict[str, Any]) -> _T:
+    return _parse_response(
+        parser, data, detail="The dataset API returned an invalid response."
+    )
+
+
+def _page(
+    data: dict[str, Any], parser: Callable[[dict[str, Any]], _T], offset: int
+) -> tuple[int, tuple[_T, ...], int | None]:
+    rows = data["results"]
+    if not isinstance(rows, list):
+        raise ValueError("Expected a list of dataset results.")
+    results = tuple(parser(_object(row)) for row in rows)
+    count = _integer(data["count"], minimum=0)
+    next_offset = _next_offset(data["next"], minimum=offset + 1)
+    if next_offset is not None and not results:
+        raise ValueError("An empty page must not have a continuation.")
+    return count, results, next_offset
+
+
+def _page_params(limit: int, offset: int, maximum: int) -> dict[str, str | int]:
+    if _integer(limit) > maximum:
+        raise ValueError(f"Page limit must be between 1 and {maximum}.")
+    return {"limit": limit, "offset": _integer(offset, minimum=0)}
+
+
+def _list_params(
+    limit: int,
+    offset: int,
+    search: str | None,
+    archived: bool,
+    order_by: DatasetOrder,
+    tags: Sequence[str] | None,
+    tag_match: str,
+) -> dict[str, str | int]:
+    params = _page_params(limit, offset, 100)
+    params.update(_tag_params(tags, tag_match))
+    params["archived"] = "true" if _boolean(archived) else "false"
+    if order_by not in ("created_at", "-created_at", "updated_at", "-updated_at"):
+        raise ValueError("Unsupported dataset order.")
+    params["order_by"] = order_by
+    if search is not None:
+        if not isinstance(search, str) or not search.strip():
+            raise ValueError("search must be a nonempty string.")
+        params["search"] = search
+    return params
+
+
+def _item_list_params(
+    dataset_id: str, revision: int | None, archived: bool, limit: int, offset: int
+) -> dict[str, str | int]:
+    params = _page_params(limit, offset, 25)
+    params["dataset"] = dataset_id
+    params["archived"] = "true" if _boolean(archived) else "false"
+    if revision is not None:
+        params["revision"] = _integer(revision)
+    return params
+
+
+def _body(fields: dict[str, Any]) -> bytes:
+    data = {
+        key: value for key, value in fields.items() if not isinstance(value, _Unset)
+    }
+    for key in ("name", "description"):
+        if key in data:
+            value = _text(data[key])
+            maximum = 400 if key == "name" else 10_000
+            if len(value) > maximum or (key == "name" and not value.strip()):
+                raise ValueError(f"Invalid dataset {key}.")
+    if "input" in data and data["input"] is None:
+        raise ValueError("Dataset inputs cannot be null.")
+    if "metadata" in data:
+        _object(data["metadata"])
+    if "tags" in data:
+        data["tags"] = _tag_names(data["tags"])
+    _validate_json(data)
+    return _encode(data)
+
+
+def _create_item_body(
+    dataset_id: str,
+    *,
+    input: JSONValue,
+    expected_output: JSONValue | _Unset,
+    source_output: JSONValue | _Unset,
+    metadata: dict[str, JSONValue] | _Unset,
+    client_item_id: str | None,
+    source_trace_id: str | None,
+    source_event_id: str | None,
+    source_timestamp: datetime | str | None,
+) -> bytes:
+    client_item_id = _identifier(client_item_id, "client_item_id")
+    source_trace_id = _identifier(source_trace_id, "source_trace_id")
+    source_event_id = _identifier(source_event_id, "source_event_id")
+    if (source_trace_id is None) != (source_timestamp is None) or (
+        source_trace_id is None and source_event_id is not None
+    ):
+        raise ValueError(
+            "Source provenance requires both source_trace_id and source_timestamp."
+        )
+    return _body(
+        dict(
+            dataset=dataset_id,
+            input=input,
+            expected_output=expected_output,
+            source_output=source_output,
+            metadata=metadata,
+            client_item_id=client_item_id,
+            source_trace_id=source_trace_id,
+            source_event_id=source_event_id,
+            source_timestamp=None
+            if source_timestamp is None
+            else _timestamp(source_timestamp),
+        )
+    )
diff --git a/posthog/ai/evaluations/_dataset_types.py b/posthog/ai/evaluations/_dataset_types.py
new file mode 100644
index 000000000..5f51ca253
--- /dev/null
+++ b/posthog/ai/evaluations/_dataset_types.py
@@ -0,0 +1,111 @@
+"""Typed dataset metadata, immutable version references, and paginated reads."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Literal
+
+from ._serialization import JSONValue
+
+DatasetOrder = Literal["created_at", "-created_at", "updated_at", "-updated_at"]
+
+
+@dataclass(frozen=True)
+class Dataset:
+    """A dataset's current metadata, separate from its immutable item revisions.
+
+    Names are unique within a project. Use ``id`` for subsequent operations.
+    Both revision fields are None until the first item is created. Metadata
+    dictionaries are local copies, not live server state.
+    """
+
+    id: str
+    name: str
+    description: str
+    metadata: dict[str, JSONValue] = field(repr=False)
+    tags: tuple[str, ...]
+    archived: bool
+    current_revision: int | None
+    current_revision_id: str | None
+    created_at: datetime
+    updated_at: datetime | None
+    created_by: dict[str, Any] | None
+    team_id: int
+
+
+@dataclass(frozen=True)
+class DatasetRevision:
+    """An immutable dataset revision. Reads use ``revision``; experiments use ``id``."""
+
+    id: str
+    dataset_id: str
+    revision: int
+    created_at: datetime
+    created_by: dict[str, Any] | None
+    team_id: int
+
+
+@dataclass(frozen=True)
+class DatasetItem:
+    """One version of a dataset case, with stable ``id`` and immutable ``version_id``.
+
+    ``dataset_revision`` and ``dataset_revision_id`` identify the revision that
+    introduced this version, which may precede the snapshot being read. Use
+    the snapshot's revision ID when creating an experiment. ``source_output``
+    is the original trace's output, not a new execution or expected answer.
+    JSON values are local copies; changing them does not update the dataset.
+    """
+
+    id: str
+    dataset_id: str
+    client_item_id: str | None
+    version: int
+    version_id: str
+    dataset_revision: int
+    dataset_revision_id: str
+    archived: bool
+    input: JSONValue = field(repr=False)
+    expected_output: JSONValue = field(repr=False)
+    source_output: JSONValue = field(repr=False)
+    metadata: dict[str, JSONValue] = field(repr=False)
+    source_trace_id: str | None
+    source_event_id: str | None
+    source_timestamp: datetime | None
+    created_at: datetime
+    updated_at: datetime | None
+    created_by: dict[str, Any] | None
+    version_created_at: datetime
+    version_created_by: dict[str, Any] | None
+    team_id: int
+
+
+@dataclass(frozen=True)
+class DatasetPage:
+    """One dataset page. Keep filters and pass ``next_offset`` to continue."""
+
+    count: int
+    results: tuple[Dataset, ...]
+    next_offset: int | None
+
+
+@dataclass(frozen=True)
+class DatasetRevisionPage:
+    """One page of revisions, newest first. None ``next_offset`` ends the list."""
+
+    count: int
+    results: tuple[DatasetRevision, ...]
+    next_offset: int | None
+
+
+@dataclass(frozen=True)
+class DatasetItemPage:
+    """One page of items or item history. None ``next_offset`` ends the list.
+
+    Keep the dataset, revision, and archive filter unchanged when continuing
+    an item listing. For a complete pinned read, prefer ``snapshot.iter_items``.
+    """
+
+    count: int
+    results: tuple[DatasetItem, ...]
+    next_offset: int | None
diff --git a/posthog/ai/evaluations/_datasets.py b/posthog/ai/evaluations/_datasets.py
new file mode 100644
index 000000000..cfe359a2e
--- /dev/null
+++ b/posthog/ai/evaluations/_datasets.py
@@ -0,0 +1,436 @@
+"""Dataset management and revision-pinned iteration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Iterator, Literal, Sequence
+from uuid import UUID
+
+from ._dataset_serialization import (
+    _body,
+    _create_item_body,
+    _dataset,
+    _item,
+    _item_list_params,
+    _list_params,
+    _page,
+    _page_params,
+    _parse,
+    _revision,
+)
+from ._dataset_types import (
+    Dataset,
+    DatasetItem,
+    DatasetItemPage,
+    DatasetOrder,
+    DatasetPage,
+    DatasetRevisionPage,
+)
+from ._serialization import (
+    JSONValue,
+    _UNSET,
+    _Unset,
+    _integer,
+    _uuid,
+)
+from ._transport import SyncTransport
+
+
+class Datasets:
+    """Manage datasets through ``OfflineEvaluations.datasets``.
+
+    Requires a personal key with ``dataset:read`` or ``dataset:write`` and the
+    datasets feature enabled. Mutations return after acknowledgment; only item
+    creates with a caller-supplied ``client_item_id`` are automatically retried.
+    Other lost write responses require inspecting state before retrying.
+    """
+
+    def __init__(self, transport: SyncTransport, project_id: int) -> None:
+        self._transport = transport
+        self._project_id = project_id
+        self._base = f"/api/projects/{project_id}/datasets/"
+        self._items = f"/api/projects/{project_id}/dataset_items/"
+
+    def create(
+        self,
+        *,
+        name: str,
+        description: str | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        tags: Sequence[str] | _Unset = _UNSET,
+    ) -> Dataset:
+        """Create an empty dataset. Names must be unique within the project.
+
+        No revision exists until the first item is created. This operation is
+        not automatically retried, including after an ambiguous acknowledgment.
+        """
+        return _parse(
+            lambda data: _dataset(data, self._project_id),
+            self._transport.request(
+                "POST",
+                self._base,
+                body=_body(
+                    dict(
+                        name=name, description=description, metadata=metadata, tags=tags
+                    )
+                ),
+                retry_safe=False,
+            ),
+        )
+
+    def get(self, dataset_id: str | UUID) -> Dataset:
+        """Fetch current metadata, including both current revision identifiers."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            self._transport.request("GET", f"{self._base}{identity}/"),
+        )
+
+    def list(
+        self,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
+        archived: bool = False,
+        order_by: DatasetOrder = "-created_at",
+        tags: Sequence[str] | None = None,
+        tag_match: Literal["any", "all"] = "any",
+    ) -> DatasetPage:
+        """Fetch one page of active datasets, or archived datasets if requested.
+
+        Search matches names, descriptions, and metadata. Keep filters and pass
+        ``next_offset`` to continue. Maximum limit is 100; tags accept 20 names.
+        """
+        params = _list_params(
+            limit, offset, search, archived, order_by, tags, tag_match
+        )
+        return _parse(
+            lambda data: DatasetPage(
+                *_page(data, lambda row: _dataset(row, self._project_id), offset)
+            ),
+            self._transport.request("GET", self._base, params=params),
+        )
+
+    def update(
+        self,
+        dataset_id: str | UUID,
+        *,
+        name: str | _Unset = _UNSET,
+        description: str | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        tags: Sequence[str] | _Unset = _UNSET,
+    ) -> Dataset:
+        """Replace supplied metadata fields; omitted fields remain unchanged.
+
+        Use description="", metadata={}, or tags=[] to clear them. Metadata
+        updates do not create revisions. Use archive/restore for archive state.
+        """
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            self._transport.request(
+                "PATCH",
+                f"{self._base}{identity}/",
+                body=_body(
+                    dict(
+                        name=name, description=description, metadata=metadata, tags=tags
+                    )
+                ),
+                retry_safe=False,
+            ),
+        )
+
+    def archive(self, dataset_id: str | UUID) -> Dataset:
+        """Archive a dataset. It stays readable but rejects item mutations."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            self._transport.request(
+                "POST", f"{self._base}{identity}/archive/", body=b"{}", retry_safe=False
+            ),
+        )
+
+    def restore(self, dataset_id: str | UUID) -> Dataset:
+        """Restore an archived dataset without changing individual item states."""
+        identity = _uuid(dataset_id)
+        return _parse(
+            lambda data: _dataset(data, self._project_id, identity),
+            self._transport.request(
+                "POST", f"{self._base}{identity}/restore/", body=b"{}", retry_safe=False
+            ),
+        )
+
+    def list_revisions(
+        self, dataset_id: str | UUID, *, limit: int = 50, offset: int = 0
+    ) -> DatasetRevisionPage:
+        """List immutable revisions newest first. Maximum page limit is 100."""
+        identity = _uuid(dataset_id)
+        params = _page_params(limit, offset, 100)
+        return _parse(
+            lambda data: DatasetRevisionPage(
+                *_page(
+                    data, lambda row: _revision(row, self._project_id, identity), offset
+                )
+            ),
+            self._transport.request(
+                "GET", f"{self._base}{identity}/revisions/", params=params
+            ),
+        )
+
+    def list_items(
+        self,
+        dataset_id: str | UUID,
+        *,
+        revision: int | None = None,
+        archived: bool = False,
+        limit: int = 25,
+        offset: int = 0,
+    ) -> DatasetItemPage:
+        """Fetch one item page, optionally at an exact numeric dataset revision.
+
+        Omitted revision reads current state for this request. Use ``snapshot``
+        for consistent multi-page evaluation reads. Archived items are excluded
+        by default; archived=True selects only archived items. Maximum limit is 25.
+        """
+        identity = _uuid(dataset_id)
+        params = _item_list_params(identity, revision, archived, limit, offset)
+        return _parse(
+            lambda data: DatasetItemPage(
+                *_page(
+                    data,
+                    lambda row: _item(
+                        row,
+                        self._project_id,
+                        dataset_id=identity,
+                        revision=revision,
+                        archived=archived,
+                    ),
+                    offset,
+                )
+            ),
+            self._transport.request("GET", self._items, params=params),
+        )
+
+    def get_item(
+        self, item_id: str | UUID, *, revision: int | None = None
+    ) -> DatasetItem:
+        """Fetch an item by stable UUID, optionally at a dataset revision number."""
+        identity = _uuid(item_id)
+        params: dict[str, str | int] = (
+            {} if revision is None else {"revision": _integer(revision)}
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, revision=revision),
+            self._transport.request("GET", f"{self._items}{identity}/", params=params),
+        )
+
+    def create_item(
+        self,
+        dataset_id: str | UUID,
+        *,
+        input: JSONValue,
+        expected_output: JSONValue | _Unset = _UNSET,
+        source_output: JSONValue | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+        client_item_id: str | None = None,
+        source_trace_id: str | None = None,
+        source_event_id: str | None = None,
+        source_timestamp: datetime | str | None = None,
+    ) -> DatasetItem:
+        """Add a case, creating its first version and a dataset revision.
+
+        ``input`` accepts any non-null JSON value. Supply a stable, case-sensitive
+        ``client_item_id`` to make identical creates retryable across processes.
+        A matching key with different current content or an archived item raises
+        a conflict. Source trace ID and timestamp must be supplied together;
+        source event ID additionally identifies an event within that trace.
+        """
+        identity = _uuid(dataset_id)
+        body = _create_item_body(
+            identity,
+            input=input,
+            expected_output=expected_output,
+            source_output=source_output,
+            metadata=metadata,
+            client_item_id=client_item_id,
+            source_trace_id=source_trace_id,
+            source_event_id=source_event_id,
+            source_timestamp=source_timestamp,
+        )
+        return _parse(
+            lambda data: _item(
+                data, self._project_id, dataset_id=identity, archived=False
+            ),
+            self._transport.request(
+                "POST", self._items, body=body, retry_safe=client_item_id is not None
+            ),
+        )
+
+    def update_item(
+        self,
+        item_id: str | UUID,
+        *,
+        base_version: int,
+        input: JSONValue | _Unset = _UNSET,
+        expected_output: JSONValue | _Unset = _UNSET,
+        metadata: dict[str, JSONValue] | _Unset = _UNSET,
+    ) -> DatasetItem:
+        """Update editable content using the observed item ``version``.
+
+        Changed content creates a version and dataset revision; identical content
+        is a no-op. Omit fields to preserve them, use expected_output=None to clear
+        the answer, or metadata={} to clear metadata. Source fields are immutable.
+        Stale versions raise a conflict without automatic refresh or retry.
+        """
+        identity = _uuid(item_id)
+        body = _body(
+            dict(
+                base_version=_integer(base_version),
+                input=input,
+                expected_output=expected_output,
+                metadata=metadata,
+            )
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=False),
+            self._transport.request(
+                "PATCH", f"{self._items}{identity}/", body=body, retry_safe=False
+            ),
+        )
+
+    def archive_item(self, item_id: str | UUID, *, base_version: int) -> DatasetItem:
+        """Archive an active item by creating a version; require its observed version."""
+        identity = _uuid(item_id)
+        body = _body(dict(base_version=_integer(base_version)))
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=True),
+            self._transport.request(
+                "POST", f"{self._items}{identity}/archive/", body=body, retry_safe=False
+            ),
+        )
+
+    def restore_item(
+        self,
+        item_id: str | UUID,
+        *,
+        base_version: int,
+        source_version: int | None = None,
+    ) -> DatasetItem:
+        """Restore an archived item, optionally copying a historical item version.
+
+        ``base_version`` is the observed current version, even when copying an
+        older ``source_version``. Restoration creates a new immutable version.
+        """
+        identity = _uuid(item_id)
+        body = _body(
+            dict(
+                base_version=_integer(base_version),
+                source_version=None
+                if source_version is None
+                else _integer(source_version),
+            )
+        )
+        return _parse(
+            lambda data: _item(data, self._project_id, id=identity, archived=False),
+            self._transport.request(
+                "POST", f"{self._items}{identity}/restore/", body=body, retry_safe=False
+            ),
+        )
+
+    def list_item_versions(
+        self, item_id: str | UUID, *, limit: int = 25, offset: int = 0
+    ) -> DatasetItemPage:
+        """List every item version, newest first. Maximum page limit is 100."""
+        identity = _uuid(item_id)
+        params = _page_params(limit, offset, 100)
+        return _parse(
+            lambda data: DatasetItemPage(
+                *_page(
+                    data, lambda row: _item(row, self._project_id, id=identity), offset
+                )
+            ),
+            self._transport.request(
+                "GET", f"{self._items}{identity}/versions/", params=params
+            ),
+        )
+
+    def snapshot(
+        self, dataset_id: str | UUID, *, revision: int | None = None
+    ) -> DatasetSnapshot:
+        """Pin a revision now; item iteration subsequently fetches that exact revision.
+
+        Omit revision to resolve latest once. Historical revisions are resolved
+        through paginated revision metadata. No items are fetched here. Raises
+        ValueError for a never-populated dataset or a nonexistent revision.
+        Keep the owning client open while iterating the returned snapshot.
+        """
+        if revision is not None:
+            _integer(revision)
+        dataset = self.get(dataset_id)
+        selected = dataset.current_revision if revision is None else revision
+        if selected is None:
+            raise ValueError(
+                "This dataset has no revision. Add an item before taking a snapshot."
+            )
+        if dataset.current_revision is None or selected > dataset.current_revision:
+            raise ValueError(f"Dataset revision {selected} does not exist.")
+        if (
+            selected == dataset.current_revision
+            and dataset.current_revision_id is not None
+        ):
+            return DatasetSnapshot(dataset, selected, dataset.current_revision_id, self)
+        # Revisions are consecutive and newest first. Concurrent writes can
+        # shift their offsets, so verify the result and scan on a miss.
+        page = self.list_revisions(
+            dataset.id, limit=1, offset=dataset.current_revision - selected
+        )
+        for candidate in page.results:
+            if candidate.revision == selected:
+                return DatasetSnapshot(dataset, selected, candidate.id, self)
+        offset = 0
+        while True:
+            page = self.list_revisions(dataset.id, limit=100, offset=offset)
+            for candidate in page.results:
+                if candidate.revision == selected:
+                    return DatasetSnapshot(dataset, selected, candidate.id, self)
+            if page.next_offset is None or (
+                page.results and page.results[-1].revision < selected
+            ):
+                raise ValueError(f"Dataset revision {selected} does not exist.")
+            offset = page.next_offset
+
+
+@dataclass(frozen=True)
+class DatasetSnapshot:
+    """A revision-pinned read handle owned by an open OfflineEvaluations client.
+
+    ``dataset`` is metadata observed when resolving the snapshot; descriptive
+    metadata is not historically versioned. Use ``revision_id`` when creating
+    an experiment, not the introducing revision on an individual DatasetItem.
+    Repeated iteration fetches the same active item versions without caching.
+    """
+
+    dataset: Dataset
+    revision: int
+    revision_id: str
+    _datasets: Datasets = field(repr=False, compare=False)
+
+    def iter_items(self, *, page_size: int = 25) -> Iterator[DatasetItem]:
+        """Lazily fetch active items at this revision, at most 25 per request.
+
+        Each iteration starts at the first page. Memory is bounded by one page;
+        fetch failures propagate so callers cannot mistake a partial read for a
+        complete dataset. An existing revision with no active items yields none.
+        """
+        _page_params(page_size, 0, 25)
+        offset = 0
+        while True:
+            page = self._datasets.list_items(
+                self.dataset.id, revision=self.revision, limit=page_size, offset=offset
+            )
+            yield from page.results
+            if page.next_offset is None:
+                return
+            offset = page.next_offset
diff --git a/posthog/ai/evaluations/_scorers.py b/posthog/ai/evaluations/_scorers.py
index 1d9e15483..a99bd7ddf 100644
--- a/posthog/ai/evaluations/_scorers.py
+++ b/posthog/ai/evaluations/_scorers.py
@@ -6,10 +6,8 @@
 import json
 from datetime import datetime
 from typing import Any, Callable, Literal, Sequence, TypeVar, cast, overload
-from urllib.parse import parse_qs, urlsplit
 from uuid import UUID
 
-from ._errors import EvaluationAPIError
 from ._scorer_types import (
     BooleanScorerConfig,
     CategoricalScorerConfig,
@@ -22,7 +20,8 @@
     ScorerVersion,
     ScorerVersionPage,
 )
-from ._tags import _response_tags, _tag_names
+from ._serialization import _integer, _next_offset, _parse_response, _text
+from ._tags import _response_tags, _tag_names, _tag_params
 from ._transport import AsyncTransport, SyncTransport
 
 
@@ -47,18 +46,6 @@ def _uuid(value: str | UUID) -> str:
         raise ValueError("Scorer and version IDs must be UUIDs.") from None
 
 
-def _integer(value: Any, *, minimum: int = 0) -> int:
-    if type(value) is not int or value < minimum:
-        raise ValueError("Expected an integer within the supported range.")
-    return value
-
-
-def _text(value: Any) -> str:
-    if not isinstance(value, str):
-        raise ValueError("Expected a string.")
-    return value
-
-
 def _optional_text(value: Any) -> str | None:
     return None if value is None else _text(value)
 
@@ -129,24 +116,18 @@ def _results(data: dict[str, Any]) -> list[dict[str, Any]]:
 
 def _scorer_page(data: dict[str, Any]) -> ScorerPage:
     next_url = _optional_text(data["next"])
-    next_offset = None
-    if next_url is not None:
-        offsets = parse_qs(urlsplit(next_url).query).get("offset")
-        if offsets is None or len(offsets) != 1:
-            raise ValueError("Missing scorer page offset.")
-        next_offset = _integer(int(offsets[0]))
     return ScorerPage(
-        count=_integer(data["count"]),
+        count=_integer(data["count"], minimum=0),
         results=tuple(_scorer(row) for row in _results(data)),
         next=next_url,
         previous=_optional_text(data["previous"]),
-        next_offset=next_offset,
+        next_offset=_next_offset(next_url),
     )
 
 
 def _version_page(data: dict[str, Any]) -> ScorerVersionPage:
     return ScorerVersionPage(
-        count=_integer(data["count"]),
+        count=_integer(data["count"], minimum=0),
         results=tuple(_version(row) for row in _results(data)),
         next_cursor=_optional_text(data["next_cursor"]),
     )
@@ -155,15 +136,9 @@ def _version_page(data: dict[str, Any]) -> ScorerVersionPage:
 def _parse(
     parser: Callable[[dict[str, Any]], _ResultT], data: dict[str, Any]
 ) -> _ResultT:
-    try:
-        return parser(data)
-    except (KeyError, TypeError, ValueError, OverflowError):
-        raise EvaluationAPIError(
-            code="invalid_response",
-            detail="The scorer API returned an invalid response.",
-            response=data,
-            persistence="unknown",
-        ) from None
+    return _parse_response(
+        parser, data, detail="The scorer API returned an invalid response."
+    )
 
 
 def _encode(data: dict[str, Any]) -> bytes:
@@ -235,11 +210,10 @@ def _list_params(
     tags: Sequence[str] | None,
     tag_match: Literal["any", "all"],
 ) -> dict[str, str | int]:
-    if tag_match not in ("any", "all"):
-        raise ValueError("tag_match must be any or all.")
+    tag_params = _tag_params(tags, tag_match)
     params: dict[str, str | int] = {
         "limit": _integer(limit, minimum=1),
-        "offset": _integer(offset),
+        "offset": _integer(offset, minimum=0),
     }
     if search is not None:
         params["search"] = search
@@ -251,11 +225,7 @@ def _list_params(
         params["archived"] = "true" if archived else "false"
     if order_by is not None:
         params["order_by"] = order_by
-    if tags is not None:
-        params["tags"] = json.dumps(_tag_names(tags, limit=20), ensure_ascii=False)
-        params["tag_match"] = tag_match
-    elif tag_match != "any":
-        params["tag_match"] = tag_match
+    params.update(tag_params)
     return params
 
 
diff --git a/posthog/ai/evaluations/_serialization.py b/posthog/ai/evaluations/_serialization.py
index b0d8bf448..83aadb280 100644
--- a/posthog/ai/evaluations/_serialization.py
+++ b/posthog/ai/evaluations/_serialization.py
@@ -3,9 +3,12 @@
 import json
 import math
 from datetime import datetime, timezone
-from typing import Any, Iterable, Union, cast
+from typing import Any, Callable, Iterable, TypeVar, Union, cast
+from urllib.parse import parse_qs, urlsplit
 from uuid import UUID
 
+from ._errors import EvaluationAPIError
+
 JSONValue = Union[
     None, bool, int, float, str, list["JSONValue"], dict[str, "JSONValue"]
 ]
@@ -22,6 +25,46 @@ def __repr__(self) -> str:
 _MAX_REQUEST_BYTES = 5 * 1024 * 1024
 _MAX_ITEM_BYTES = 1024 * 1024
 _MAX_RESULT_BYTES = 256 * 1024
+_ResponseT = TypeVar("_ResponseT")
+
+
+def _parse_response(
+    parser: Callable[[dict[str, Any]], _ResponseT],
+    data: dict[str, Any],
+    *,
+    detail: str,
+) -> _ResponseT:
+    try:
+        return parser(data)
+    except (KeyError, TypeError, ValueError, OverflowError):
+        raise EvaluationAPIError(
+            code="invalid_response",
+            detail=detail,
+            response=data,
+            persistence="unknown",
+        ) from None
+
+
+def _integer(value: Any, *, minimum: int = 1) -> int:
+    if type(value) is not int or value < minimum:
+        raise ValueError(f"Expected an integer greater than or equal to {minimum}.")
+    return value
+
+
+def _text(value: Any) -> str:
+    if not isinstance(value, str):
+        raise ValueError("Expected a string.")
+    return value
+
+
+def _next_offset(value: Any, *, minimum: int = 0) -> int | None:
+    if value is None:
+        return None
+    # Extract only the continuation. Never send credentials to a response URL.
+    offsets = parse_qs(urlsplit(_text(value)).query).get("offset")
+    if offsets is None or len(offsets) != 1:
+        raise ValueError("Missing page offset.")
+    return _integer(int(offsets[0]), minimum=minimum)
 
 
 def _uuid(value: object) -> str:
@@ -51,14 +94,14 @@ def _identifier(value: object, field: str, limit: int = 255) -> str | None:
     return value
 
 
-def _encode(value: object) -> bytes:
+def _encode(value: object, *, sort_keys: bool = True) -> bytes:
     try:
         return json.dumps(
             value,
             ensure_ascii=False,
             allow_nan=False,
             separators=(",", ":"),
-            sort_keys=True,
+            sort_keys=sort_keys,
         ).encode("utf-8")
     except (TypeError, ValueError, UnicodeError) as exc:
         raise ValueError(
diff --git a/posthog/ai/evaluations/_tags.py b/posthog/ai/evaluations/_tags.py
index be1448f70..b78f0ca17 100644
--- a/posthog/ai/evaluations/_tags.py
+++ b/posthog/ai/evaluations/_tags.py
@@ -1,7 +1,8 @@
-"""Shared validation for mutable scorer and experiment tags."""
+"""Shared validation and filters for scorer, dataset, and experiment tags."""
 
 from __future__ import annotations
 
+import json
 from collections.abc import Sequence
 from typing import Any
 
@@ -26,3 +27,14 @@ def _response_tags(value: Any) -> tuple[str, ...]:
     if not isinstance(value, list) or any(not isinstance(tag, str) for tag in value):
         raise ValueError("Expected a list of tag names.")
     return tuple(value)
+
+
+def _tag_params(tags: Sequence[str] | None, tag_match: str) -> dict[str, str | int]:
+    if tag_match not in ("any", "all"):
+        raise ValueError("tag_match must be any or all.")
+    params: dict[str, str | int] = {}
+    if tags is not None:
+        params["tags"] = json.dumps(_tag_names(tags, limit=20), ensure_ascii=False)
+    if tags is not None or tag_match != "any":
+        params["tag_match"] = tag_match
+    return params
diff --git a/posthog/ai/evaluations/_types.py b/posthog/ai/evaluations/_types.py
index c6862b37d..7992ac1c9 100644
--- a/posthog/ai/evaluations/_types.py
+++ b/posthog/ai/evaluations/_types.py
@@ -8,6 +8,7 @@
 
 from typing_extensions import TypedDict
 
+from ._dataset_types import DatasetItem
 from ._errors import EvaluationAPIError
 from ._serialization import (
     JSONValue,
@@ -135,6 +136,45 @@ def to_dict(self) -> dict[str, Any]:
         """Return a defensive, JSON-serializable copy of the complete declaration."""
         return json.loads(self._json)
 
+    @classmethod
+    def from_dataset_item(
+        cls,
+        item: DatasetItem,
+        *,
+        output: JSONValue | _Unset = _UNSET,
+        id: str | UUID | None = None,
+        case_key: str | None = None,
+        trial: str | None = None,
+        application_trace_id: str | None = None,
+    ) -> EvaluationItem:
+        """Declare one execution of a dataset case, preserving its exact version.
+
+        Copies input, expected output, and metadata; supply the new execution's
+        output and trace ID. Source output/provenance are never substituted.
+        A fresh execution UUID is generated unless id is supplied. Reuse the
+        returned item across scorers; call again for each independent trial.
+        ``case_key`` defaults to the caller-owned client item ID, or stable item
+        UUID. Omit output for an execution that failed before producing one.
+        Use the owning snapshot's revision_id when creating the experiment.
+        """
+        if not isinstance(item, DatasetItem):
+            raise TypeError("Expected a DatasetItem.")
+        if item.archived:
+            raise ValueError("Archived dataset items cannot be evaluated.")
+        return cls(
+            id=id,
+            input=item.input,
+            output=output,
+            expected_output=item.expected_output,
+            metadata=item.metadata,
+            case_key=(item.client_item_id or item.id) if case_key is None else case_key,
+            trial=trial,
+            dataset_item_identifier=item.id,
+            dataset_item_version_identifier=item.version_id,
+            dataset_item_version_id=item.version_id,
+            application_trace_id=application_trace_id,
+        )
+
     @classmethod
     def from_dict(cls, data: Mapping[str, Any]) -> EvaluationItem:
         """Restore a saved declaration, including its required original UUID."""
diff --git a/posthog/test/ai/test_evaluations_datasets.py b/posthog/test/ai/test_evaluations_datasets.py
new file mode 100644
index 000000000..e90d34005
--- /dev/null
+++ b/posthog/test/ai/test_evaluations_datasets.py
@@ -0,0 +1,838 @@
+import asyncio
+import copy
+import importlib.util
+import inspect
+import json
+from dataclasses import FrozenInstanceError, replace
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import AsyncMock, Mock, patch
+from uuid import UUID
+
+import httpx
+import pytest
+import requests
+
+from posthog.ai.evaluations import (
+    AsyncOfflineEvaluations,
+    DatasetItemPage,
+    EvaluationAPIError,
+    EvaluationItem,
+    EvaluationResult,
+    OfflineEvaluations,
+)
+from posthog.ai.evaluations import _client
+from posthog.ai.evaluations._transport import AsyncTransport, SyncTransport
+
+from .test_evaluations import respond as respond_to_experiment
+from .test_evaluations_scorers import scorer_response
+
+DATASET_ID = "015e4ac4-3659-456b-998c-4345b4e4c846"
+ITEM_ID = "7d1e9d28-9b64-4c95-b4ad-3e6fa6b975b1"
+OTHER_ITEM_ID = "b492bf6b-bb45-4374-aefb-e40a8eecfc62"
+VERSION_ID = "9e2bdd1a-ad9e-4a96-9bc0-77a7f4d8b35e"
+REVISION_ID = "ba71a1bb-836f-4c19-9d06-1d36d44948a4"
+OLD_REVISION_ID = "a4137aa9-4e27-4829-928b-568cc55a0082"
+TIMESTAMP = "2026-10-20T10:00:00Z"
+BASE = "/api/projects/123/datasets/"
+ITEMS = "/api/projects/123/dataset_items/"
+
+
+def dataset_response(**overrides):
+    return {
+        "id": DATASET_ID,
+        "name": "Capital cities",
+        "description": "Regression cases",
+        "metadata": {"owner": "support"},
+        "tags": ["regression"],
+        "archived": False,
+        "current_revision": 3,
+        "current_revision_id": REVISION_ID,
+        "created_at": TIMESTAMP,
+        "updated_at": None,
+        "created_by": None,
+        "team_id": 123,
+        **overrides,
+    }
+
+
+def revision_response(**overrides):
+    return {
+        "id": OLD_REVISION_ID,
+        "dataset_id": DATASET_ID,
+        "revision": 1,
+        "created_at": TIMESTAMP,
+        "created_by": None,
+        "team_id": 123,
+        **overrides,
+    }
+
+
+def item_response(**overrides):
+    return {
+        "id": ITEM_ID,
+        "dataset": DATASET_ID,
+        "client_item_id": "capital-france",
+        "version": 2,
+        "version_id": VERSION_ID,
+        "dataset_revision": 2,
+        "dataset_revision_id": OLD_REVISION_ID,
+        "archived": False,
+        "input": {"question": "Capital of France?"},
+        "expected_output": "Paris",
+        "source_output": "Lyon",
+        "metadata": {"category": ["geography"]},
+        "source_trace_id": "source-trace",
+        "source_event_id": "source-event",
+        "source_timestamp": TIMESTAMP,
+        "created_at": TIMESTAMP,
+        "updated_at": TIMESTAMP,
+        "created_by": None,
+        "version_created_at": TIMESTAMP,
+        "version_created_by": None,
+        "team_id": 123,
+        **overrides,
+    }
+
+
+def page_response(*rows, next_offset=None, count=None):
+    return {
+        "count": len(rows) if count is None else count,
+        "results": list(rows),
+        "next": None
+        if next_offset is None
+        else f"https://us.posthog.com{ITEMS}?offset={next_offset}",
+        "previous": None,
+    }
+
+
+def invoke(method, *args, **kwargs):
+    result = method(*args, **kwargs)
+    return asyncio.run(result) if inspect.isawaitable(result) else result
+
+
+def collect(iterator):
+    async def consume():
+        return [item async for item in iterator]
+
+    return asyncio.run(consume()) if hasattr(iterator, "__aiter__") else list(iterator)
+
+
+@pytest.fixture(params=[False, True], ids=["sync", "async"])
+def client(request, monkeypatch):
+    transport = Mock(spec=SyncTransport)
+    if request.param:
+        transport = AsyncMock(spec=AsyncTransport)
+        monkeypatch.setattr(_client, "AsyncTransport", lambda *args: transport)
+        evaluations = AsyncOfflineEvaluations(project_id=123, secret_key="phx_example")
+    else:
+        monkeypatch.setattr(_client, "SyncTransport", lambda *args: transport)
+        evaluations = OfflineEvaluations(project_id=123, secret_key="phx_example")
+    return evaluations, transport
+
+
+def test_dataset_metadata_omission_clearing_and_empty_revision(client):
+    evaluations, transport = client
+    response = dataset_response(current_revision=None, current_revision_id=None)
+    transport.request.return_value = response
+    dataset = invoke(evaluations.datasets.create, name="Capital cities")
+    assert dataset.current_revision is None
+    assert dataset.current_revision_id is None
+    assert dataset.created_at.tzinfo == timezone.utc
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {
+        "name": "Capital cities"
+    }
+    assert transport.request.call_args.kwargs["retry_safe"] is False
+
+    response["metadata"]["owner"] = "changed"
+    assert dataset.metadata == {"owner": "support"}
+    with pytest.raises(FrozenInstanceError):
+        dataset.id = OTHER_ITEM_ID
+
+    invoke(
+        evaluations.datasets.update,
+        UUID(DATASET_ID),
+        description="",
+        metadata={},
+        tags=[],
+    )
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {
+        "description": "",
+        "metadata": {},
+        "tags": [],
+    }
+    invoke(evaluations.datasets.update, DATASET_ID, name="Renamed")
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {"name": "Renamed"}
+    assert transport.request.call_args.kwargs["retry_safe"] is False
+
+
+@pytest.mark.parametrize("input", [False, 0, "", [], {"messages": []}])
+def test_item_creation_preserves_json_values_and_source_provenance(client, input):
+    evaluations, transport = client
+    transport.request.return_value = item_response(input=input)
+    item = invoke(
+        evaluations.datasets.create_item,
+        DATASET_ID,
+        input=input,
+        expected_output=None,
+        source_output="original",
+        metadata={},
+        client_item_id="capital-france",
+        source_trace_id="trace",
+        source_event_id="event",
+        source_timestamp=datetime(2026, 10, 20, tzinfo=timezone.utc),
+    )
+    body = json.loads(transport.request.call_args.kwargs["body"])
+    assert item.input == input
+    assert body == {
+        "dataset": DATASET_ID,
+        "input": input,
+        "expected_output": None,
+        "source_output": "original",
+        "metadata": {},
+        "client_item_id": "capital-france",
+        "source_trace_id": "trace",
+        "source_event_id": "event",
+        "source_timestamp": "2026-10-20T00:00:00+00:00",
+    }
+    assert transport.request.call_args.kwargs["retry_safe"] is True
+
+
+def test_item_updates_distinguish_omission_from_clear_and_protect_source_fields(client):
+    evaluations, transport = client
+    transport.request.return_value = item_response()
+    invoke(
+        evaluations.datasets.update_item,
+        ITEM_ID,
+        base_version=2,
+        expected_output=None,
+        metadata={},
+    )
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {
+        "base_version": 2,
+        "expected_output": None,
+        "metadata": {},
+    }
+    assert transport.request.call_args.kwargs["retry_safe"] is False
+    invoke(evaluations.datasets.update_item, ITEM_ID, base_version=2, input="new")
+    assert json.loads(transport.request.call_args.kwargs["body"]) == {
+        "base_version": 2,
+        "input": "new",
+    }
+    transport.request.reset_mock()
+    with pytest.raises(TypeError):
+        invoke(
+            evaluations.datasets.update_item,
+            ITEM_ID,
+            base_version=2,
+            source_output="overwrite",
+        )
+    transport.request.assert_not_called()
+
+
+@pytest.mark.parametrize("scope", ["dataset", "item"])
+def test_archive_and_restore_use_explicit_transitions(client, scope):
+    evaluations, transport = client
+    namespace = evaluations.datasets
+    if scope == "dataset":
+        transport.request.return_value = dataset_response(archived=True)
+        archived = invoke(namespace.archive, DATASET_ID)
+        assert transport.request.call_args.args == (
+            "POST",
+            BASE + DATASET_ID + "/archive/",
+        )
+        transport.request.return_value = dataset_response()
+        restored = invoke(namespace.restore, DATASET_ID)
+        assert transport.request.call_args.args == (
+            "POST",
+            BASE + DATASET_ID + "/restore/",
+        )
+    else:
+        transport.request.return_value = item_response(archived=True, version=3)
+        archived = invoke(namespace.archive_item, ITEM_ID, base_version=2)
+        assert json.loads(transport.request.call_args.kwargs["body"]) == {
+            "base_version": 2
+        }
+        transport.request.return_value = item_response(version=4)
+        restored = invoke(
+            namespace.restore_item, ITEM_ID, base_version=3, source_version=1
+        )
+        assert json.loads(transport.request.call_args.kwargs["body"]) == {
+            "base_version": 3,
+            "source_version": 1,
+        }
+        assert transport.request.call_args.args == (
+            "POST",
+            ITEMS + ITEM_ID + "/restore/",
+        )
+    assert archived.archived is True
+    assert restored.archived is False
+    assert all(
+        call.kwargs["retry_safe"] is False for call in transport.request.call_args_list
+    )
+
+
+@pytest.mark.parametrize("tags", [None, [], [" Quality "]])
+@pytest.mark.parametrize("tag_match", ["any", "all"])
+def test_filtered_dataset_pages_keep_continuation_and_normalized_tags(
+    client, tags, tag_match
+):
+    evaluations, transport = client
+    transport.request.return_value = page_response(
+        dataset_response(tags=["quality"]), next_offset=50, count=51
+    )
+    page = invoke(
+        evaluations.datasets.list,
+        search="capital",
+        archived=True,
+        order_by="updated_at",
+        tags=tags,
+        tag_match=tag_match,
+    )
+    assert page.next_offset == 50
+    assert page.count == 51
+    assert page.results[0].tags == ("quality",)
+    assert transport.request.call_args.kwargs["params"] == {
+        "limit": 50,
+        "offset": 0,
+        "search": "capital",
+        "archived": "true",
+        "order_by": "updated_at",
+        **({"tags": json.dumps(tags)} if tags is not None else {}),
+        **({"tag_match": tag_match} if tags is not None or tag_match != "any" else {}),
+    }
+
+
+@pytest.mark.parametrize(
+    "field", ["input", "expected_output", "source_output", "metadata"]
+)
+def test_item_json_preserves_response_key_order_without_aliasing(client, field):
+    evaluations, transport = client
+    value = {"z": [{"y": 1, "b": 2}], "a": 3}
+    transport.request.return_value = item_response(**{field: value})
+
+    item = invoke(evaluations.datasets.get_item, ITEM_ID)
+    copied = getattr(item, field)
+    assert list(copied) == ["z", "a"]
+    assert list(copied["z"][0]) == ["y", "b"]
+    value["z"][0]["y"] = 99
+    assert copied["z"][0]["y"] == 1
+
+
+def test_item_history_and_historical_get_keep_stable_and_version_ids_separate(client):
+    evaluations, transport = client
+    transport.request.return_value = page_response(
+        item_response(), item_response(version=1)
+    )
+    page = invoke(evaluations.datasets.list_item_versions, UUID(ITEM_ID), limit=100)
+    assert isinstance(page, DatasetItemPage)
+    assert [row.version for row in page.results] == [2, 1]
+    assert transport.request.call_args.args == ("GET", ITEMS + ITEM_ID + "/versions/")
+    transport.request.return_value = item_response()
+    item = invoke(evaluations.datasets.get_item, UUID(ITEM_ID), revision=3)
+    assert item.id == ITEM_ID and item.version_id == VERSION_ID
+    assert item.dataset_revision == 2
+    assert transport.request.call_args.kwargs["params"] == {"revision": 3}
+
+
+def test_snapshot_pins_before_iteration_and_never_follows_remote_pagination_urls(
+    client,
+):
+    evaluations, transport = client
+    latest = dataset_response()
+    transport.request.return_value = latest
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID)
+    assert transport.request.call_count == 1
+    assert snapshot.revision == 3 and snapshot.revision_id == REVISION_ID
+    latest.update(current_revision=4, current_revision_id=OLD_REVISION_ID)
+    iterator = snapshot.iter_items(page_size=1)
+    assert transport.request.call_count == 1
+    first = page_response(item_response(), next_offset=1, count=2)
+    first["next"] = "https://untrusted.example/api/?offset=1&revision=4"
+    transport.request.side_effect = [
+        first,
+        page_response(item_response(id=OTHER_ITEM_ID), count=2),
+    ]
+    items = collect(iterator)
+    assert [item.id for item in items] == [ITEM_ID, OTHER_ITEM_ID]
+    for call in transport.request.call_args_list[1:]:
+        assert call.args == ("GET", ITEMS)
+        assert call.kwargs["params"]["revision"] == 3
+        assert call.kwargs["params"]["archived"] == "false"
+    assert transport.request.call_args.kwargs["params"]["offset"] == 1
+
+
+def test_historical_snapshot_looks_up_expected_offset_without_scanning(client):
+    evaluations, transport = client
+    transport.request.side_effect = [
+        dataset_response(current_revision=10_000),
+        page_response(revision_response(), count=10_000),
+    ]
+
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID, revision=1)
+
+    assert snapshot.revision == 1 and snapshot.revision_id == OLD_REVISION_ID
+    assert transport.request.call_count == 2
+    assert transport.request.call_args.args == (
+        "GET",
+        BASE + DATASET_ID + "/revisions/",
+    )
+    assert transport.request.call_args.kwargs["params"] == {"limit": 1, "offset": 9999}
+
+
+def test_historical_snapshot_falls_back_when_concurrent_writes_shift_offset(client):
+    evaluations, transport = client
+    transport.request.side_effect = [
+        dataset_response(),
+        page_response(revision_response(revision=2), next_offset=3, count=4),
+        page_response(
+            revision_response(revision=4),
+            revision_response(revision=3),
+            revision_response(revision=2),
+            revision_response(),
+        ),
+    ]
+
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID, revision=1)
+
+    assert snapshot.revision == 1 and snapshot.revision_id == OLD_REVISION_ID
+    assert [call.kwargs["params"] for call in transport.request.call_args_list[1:]] == [
+        {"limit": 1, "offset": 2},
+        {"limit": 100, "offset": 0},
+    ]
+
+
+def test_historical_snapshot_resolves_revision_uuid_across_pages(client):
+    evaluations, transport = client
+    transport.request.side_effect = [
+        dataset_response(),
+        page_response(count=2),
+        page_response(
+            revision_response(id=REVISION_ID, revision=3), next_offset=1, count=2
+        ),
+        page_response(revision_response(), count=2),
+        page_response(item_response(dataset_revision=1)),
+    ]
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID, revision=1)
+    assert snapshot.revision_id == OLD_REVISION_ID
+    assert transport.request.call_args.kwargs["params"]["offset"] == 1
+    assert snapshot.dataset.current_revision == 3
+    assert [
+        call.kwargs["params"]["offset"] for call in transport.request.call_args_list[1:]
+    ] == [2, 0, 1]
+    assert len(collect(snapshot.iter_items())) == 1
+    assert transport.request.call_args.kwargs["params"]["revision"] == 1
+
+
+def test_never_populated_and_missing_revisions_are_distinct_from_empty_snapshot(client):
+    evaluations, transport = client
+    transport.request.return_value = dataset_response(
+        current_revision=None, current_revision_id=None
+    )
+    with pytest.raises(ValueError, match="no revision"):
+        invoke(evaluations.datasets.snapshot, DATASET_ID)
+    transport.request.side_effect = [dataset_response(), page_response()]
+    with pytest.raises(ValueError, match="does not exist"):
+        invoke(evaluations.datasets.snapshot, DATASET_ID, revision=9)
+    assert transport.request.call_args.args == ("GET", BASE + DATASET_ID + "/")
+    transport.request.side_effect = [dataset_response(archived=True), page_response()]
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID)
+    assert collect(snapshot.iter_items()) == []
+
+
+def test_missing_historical_revision_stops_once_history_passes_it(client):
+    evaluations, transport = client
+    transport.request.side_effect = [
+        dataset_response(),
+        page_response(revision_response(), count=2),
+        page_response(revision_response(), next_offset=1, count=2),
+    ]
+    with pytest.raises(ValueError, match="revision 2 does not exist"):
+        invoke(evaluations.datasets.snapshot, DATASET_ID, revision=2)
+    assert transport.request.call_count == 3
+
+
+def test_snapshot_propagates_partial_read_failure_and_can_be_iterated_again(client):
+    evaluations, transport = client
+    transport.request.return_value = dataset_response()
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID)
+    failure = EvaluationAPIError(status=503, persistence="unknown")
+    transport.request.side_effect = [
+        page_response(item_response(), next_offset=1, count=2),
+        failure,
+    ]
+    with pytest.raises(EvaluationAPIError) as caught:
+        collect(snapshot.iter_items(page_size=1))
+    assert caught.value is failure
+    transport.request.side_effect = [page_response(item_response())]
+    assert len(collect(snapshot.iter_items())) == 1
+    assert transport.request.call_args.kwargs["params"]["offset"] == 0
+
+
+@pytest.mark.parametrize(
+    "next_url,rows",
+    [
+        ("?offset=0", [item_response()]),
+        ("?offset=-1", [item_response()]),
+        ("?offset=one", [item_response()]),
+        ("?offset=1&offset=2", [item_response()]),
+        ("?cursor=next", [item_response()]),
+        ("?offset=1", []),
+    ],
+)
+def test_invalid_continuations_cannot_loop_or_silently_truncate(client, next_url, rows):
+    evaluations, transport = client
+    transport.request.return_value = {"count": 2, "results": rows, "next": next_url}
+    with pytest.raises(EvaluationAPIError, match="no acknowledgment") as caught:
+        invoke(evaluations.datasets.list_items, DATASET_ID)
+    assert caught.value.code == "invalid_response"
+
+
+@pytest.mark.parametrize(
+    "overrides",
+    [
+        {"dataset": OTHER_ITEM_ID},
+        {"team_id": 999},
+        {"dataset_revision": 4},
+        {"archived": True},
+        {"version_id": "invalid"},
+        {"metadata": []},
+        {"input": None},
+        {"version": True},
+        {"created_at": "2026-10-20"},
+    ],
+)
+def test_invalid_item_responses_cannot_enter_a_pinned_run(client, overrides):
+    evaluations, transport = client
+    transport.request.return_value = page_response(item_response(**overrides))
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(evaluations.datasets.list_items, DATASET_ID, revision=3)
+    assert caught.value.code == "invalid_response"
+    assert caught.value.persistence == "unknown"
+    assert caught.value.detail == "The dataset API returned an invalid response."
+    assert caught.value.response == transport.request.return_value
+
+
+@pytest.mark.parametrize(
+    "overrides",
+    [
+        {"id": OTHER_ITEM_ID},
+        {"team_id": 999},
+        {"current_revision": None},
+        {"current_revision_id": None},
+        {"current_revision": True},
+    ],
+)
+def test_invalid_dataset_metadata_cannot_pin_a_snapshot(client, overrides):
+    evaluations, transport = client
+    transport.request.return_value = dataset_response(**overrides)
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(evaluations.datasets.snapshot, DATASET_ID)
+    assert caught.value.code == "invalid_response"
+
+
+@pytest.mark.parametrize(
+    "method,args,kwargs",
+    [
+        ("create", (), {"name": " "}),
+        ("update", (DATASET_ID,), {"description": None}),
+        ("update", (DATASET_ID,), {"metadata": None}),
+        ("update", (DATASET_ID,), {"tags": "tag"}),
+        ("get", ("../other-project",), {}),
+        ("list", (), {"limit": 101}),
+        ("list", (), {"offset": -1}),
+        ("list", (), {"archived": "false"}),
+        ("list", (), {"tag_match": "invalid"}),
+        ("list_items", (DATASET_ID,), {"limit": 26}),
+        ("list_items", (DATASET_ID,), {"revision": 0}),
+        ("snapshot", (DATASET_ID,), {"revision": True}),
+        ("create_item", (DATASET_ID,), {"input": None}),
+        ("create_item", (DATASET_ID,), {"input": float("nan")}),
+        ("create_item", (DATASET_ID,), {"input": {1: "invalid key"}}),
+        ("create_item", (DATASET_ID,), {"input": "q", "client_item_id": ""}),
+        ("create_item", (DATASET_ID,), {"input": "q", "source_trace_id": "trace"}),
+        ("create_item", (DATASET_ID,), {"input": "q", "source_event_id": "event"}),
+        ("create_item", (DATASET_ID,), {"input": "q", "source_timestamp": TIMESTAMP}),
+        (
+            "create_item",
+            (DATASET_ID,),
+            {
+                "input": "q",
+                "source_trace_id": "trace",
+                "source_timestamp": "2026-10-20",
+            },
+        ),
+        ("update_item", (ITEM_ID,), {"base_version": 0}),
+        ("update_item", (ITEM_ID,), {"base_version": 2, "input": None}),
+        ("restore_item", (ITEM_ID,), {"base_version": 2, "source_version": False}),
+    ],
+)
+def test_invalid_requests_fail_before_network_io(client, method, args, kwargs):
+    evaluations, transport = client
+    with pytest.raises(ValueError):
+        invoke(getattr(evaluations.datasets, method), *args, **kwargs)
+    transport.request.assert_not_called()
+
+
+def test_conflicts_and_scope_errors_preserve_actionable_server_details(client):
+    evaluations, transport = client
+    conflict = EvaluationAPIError(
+        status=409,
+        code="stale_version",
+        response={"current_version": 3, "current_item_id": ITEM_ID},
+        persistence="rejected",
+    )
+    transport.request.side_effect = conflict
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(
+            evaluations.datasets.update_item,
+            ITEM_ID,
+            base_version=2,
+            expected_output="new",
+        )
+    assert caught.value is conflict
+    assert caught.value.response["current_version"] == 3
+    transport.request.assert_called_once()
+    transport.request.side_effect = EvaluationAPIError(
+        status=403, persistence="rejected"
+    )
+    with pytest.raises(EvaluationAPIError) as caught:
+        invoke(evaluations.datasets.get, DATASET_ID)
+    assert caught.value.status == 403
+
+
+def test_dataset_to_execution_copies_payload_and_keeps_trials_independent(client):
+    evaluations, transport = client
+    response = item_response()
+    transport.request.return_value = response
+    case = invoke(evaluations.datasets.get_item, ITEM_ID)
+    original = copy.deepcopy(response)
+    response["metadata"]["category"].append("changed")
+    output = {"answer": "Paris"}
+    first = EvaluationItem.from_dataset_item(
+        case, output=output, trial="1", application_trace_id="new-trace"
+    )
+    second = EvaluationItem.from_dataset_item(case, output="Paris", trial="2")
+    assert first.id != second.id and first.id != case.id
+    data = first.to_dict()
+    assert data["dataset_item_version_id"] == VERSION_ID
+    assert data["dataset_item_identifier"] == ITEM_ID
+    assert data["dataset_item_version_identifier"] == VERSION_ID
+    assert data["case_key"] == "capital-france"
+    assert data["application_trace_id"] == "new-trace"
+    assert data["payload"] == {
+        "input": original["input"],
+        "output": output,
+        "expected_output": "Paris",
+        "metadata": original["metadata"],
+    }
+    output["answer"] = "changed"
+    case.metadata["category"].append("changed locally")
+    assert first.to_dict() == data
+    assert "application_trace_id" not in second.to_dict()
+    assert EvaluationItem.from_dict(data).to_dict() == data
+    assert (
+        EvaluationItem.from_dataset_item(replace(case, client_item_id=None)).to_dict()[
+            "case_key"
+        ]
+        == ITEM_ID
+    )
+    assert "output" not in EvaluationItem.from_dataset_item(case).to_dict()["payload"]
+    explicit = EvaluationItem.from_dataset_item(
+        case, id=first.id, case_key="override", output=None
+    )
+    assert explicit.id == first.id
+    assert explicit.to_dict()["case_key"] == "override"
+    assert explicit.to_dict()["payload"]["output"] is None
+    with pytest.raises(ValueError, match="Archived"):
+        EvaluationItem.from_dataset_item(replace(case, archived=True))
+
+
+def test_dataset_scorer_experiment_flow_pins_both_versions_and_reuses_execution(client):
+    evaluations, transport = client
+    bodies = []
+
+    def respond(method, path, *, body=None, **kwargs):
+        if path == BASE + DATASET_ID + "/":
+            return dataset_response()
+        if path == ITEMS:
+            return page_response(item_response())
+        if "score_definitions" in path:
+            return scorer_response()
+        if path.endswith("/upload/"):
+            bodies.append(json.loads(body))
+        return respond_to_experiment(method, path, body=body, **kwargs)
+
+    transport.request.side_effect = respond
+    snapshot = invoke(evaluations.datasets.snapshot, DATASET_ID)
+    scorer = invoke(evaluations.scorers.get, scorer_response()["id"])
+    experiment = invoke(
+        evaluations.create_experiment,
+        name="Capital cities",
+        dataset_revision_id=snapshot.revision_id,
+    )
+    case = collect(snapshot.iter_items())[0]
+    item = EvaluationItem.from_dataset_item(case, output="Paris")
+    results = [
+        EvaluationResult(item=item, scorer_version_id=version, value=True)
+        for version in [scorer.current_version_id, OTHER_ITEM_ID]
+    ]
+    invoke(experiment.upload_results, results)
+    invoke(experiment.complete)
+    assert experiment.submission["dataset_revision_id"] == REVISION_ID
+    assert experiment.submission["dataset_revision_id"] != case.dataset_revision_id
+    assert len(bodies[0]["items"]) == 1
+    assert {result["item_id"] for result in bodies[0]["results"]} == {item.id}
+    assert bodies[0]["items"][0]["dataset_item_version_id"] == VERSION_ID
+
+
+@pytest.mark.parametrize("asynchronous", [False, True], ids=["sync", "async"])
+@pytest.mark.parametrize("client_item_id", [None, "stable-key"])
+def test_lost_item_create_acknowledgment_only_retries_with_explicit_identity(
+    asynchronous, client_item_id
+):
+    attempts = []
+
+    def payload(attempt):
+        attempts.append(attempt)
+        if len(attempts) == 1:
+            raise (
+                requests.ReadTimeout()
+                if not asynchronous
+                else httpx.ReadTimeout("lost acknowledgment")
+            )
+        return item_response(client_item_id=client_item_id)
+
+    async def run_async():
+        async with AsyncOfflineEvaluations(
+            project_id=123, secret_key="phx_example"
+        ) as evaluations:
+
+            def respond(request):
+                return httpx.Response(200, json=payload((request.url, request.content)))
+
+            await evaluations._transport._client.aclose()
+            evaluations._transport._client = httpx.AsyncClient(
+                transport=httpx.MockTransport(respond)
+            )
+            with patch(
+                "posthog.ai.evaluations._transport.asyncio.sleep",
+                new_callable=AsyncMock,
+            ):
+                return await evaluations.datasets.create_item(
+                    DATASET_ID, input="q", client_item_id=client_item_id
+                )
+
+    def run_sync():
+        with OfflineEvaluations(
+            project_id=123, secret_key="phx_example"
+        ) as evaluations:
+
+            def respond(method, url, **kwargs):
+                data = payload((url, kwargs["data"]))
+                result = requests.Response()
+                result.status_code = 200
+                result._content = json.dumps(data).encode()
+                return result
+
+            with (
+                patch.object(
+                    evaluations._transport._session, "request", side_effect=respond
+                ),
+                patch("posthog.ai.evaluations._transport.time.sleep"),
+            ):
+                return evaluations.datasets.create_item(
+                    DATASET_ID, input="q", client_item_id=client_item_id
+                )
+
+    def run():
+        return asyncio.run(run_async()) if asynchronous else run_sync()
+
+    if client_item_id is None:
+        with pytest.raises(EvaluationAPIError) as caught:
+            run()
+        assert caught.value.persistence == "unknown"
+        assert len(attempts) == 1
+    else:
+        assert run().id == ITEM_ID
+        assert len(attempts) == 2
+        assert attempts[0] == attempts[1]
+
+
+def test_dataset_example_replays_persisted_cases_without_refetching_or_rerunning(
+    monkeypatch, tmp_path
+):
+    example = Path(__file__).parents[3] / "examples/example-offline-evaluations/main.py"
+    spec = importlib.util.spec_from_file_location("dataset_evaluation_example", example)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    state_path = tmp_path / "dataset-run.json"
+    monkeypatch.setenv("POSTHOG_PROJECT_ID", "123")
+    monkeypatch.setenv("POSTHOG_SECRET_KEY", "never-save-this-secret")
+    monkeypatch.setenv("POSTHOG_HOST", "https://us.posthog.com")
+    monkeypatch.setenv("POSTHOG_SCORER_VERSION_ID", VERSION_ID)
+    monkeypatch.setattr(
+        "sys.argv",
+        [str(example), "--dataset-id", DATASET_ID, "--state", str(state_path)],
+    )
+    transport = Mock(spec=SyncTransport)
+    monkeypatch.setattr(_client, "SyncTransport", lambda *args: transport)
+
+    def respond(method, path, **kwargs):
+        if method == "GET":
+            assert not state_path.exists()
+            if path == BASE + DATASET_ID + "/":
+                return dataset_response()
+            return page_response(item_response(input="Capital of France?"))
+        assert state_path.exists()
+        assert "never-save-this-secret" not in state_path.read_text()
+        return respond_to_experiment(method, path, **kwargs)
+
+    transport.request.side_effect = respond
+    module.main()
+    state = json.loads(state_path.read_text())
+    assert state["experiment"]["dataset_revision_id"] == REVISION_ID
+    assert state["items"][0]["dataset_item_version_id"] == VERSION_ID
+    assert state["results"][0]["value"] is True
+    first_writes = [
+        call for call in transport.request.call_args_list if call.args[0] == "POST"
+    ]
+    transport.request.reset_mock()
+    monkeypatch.setattr(
+        module,
+        "capital_answer",
+        Mock(side_effect=AssertionError("Execution must not replay")),
+    )
+    module.main()
+    assert transport.request.call_args_list == first_writes
+
+
+@pytest.mark.parametrize("asynchronous", [False, True], ids=["sync", "async"])
+def test_snapshot_cannot_read_after_owning_client_closes(asynchronous):
+    async def run_async():
+        async with AsyncOfflineEvaluations(
+            project_id=123, secret_key="phx_example"
+        ) as evaluations:
+            with patch.object(
+                evaluations._transport,
+                "request",
+                new_callable=AsyncMock,
+                return_value=dataset_response(),
+            ):
+                snapshot = await evaluations.datasets.snapshot(DATASET_ID)
+        return [item async for item in snapshot.iter_items()]
+
+    def run_sync():
+        with OfflineEvaluations(
+            project_id=123, secret_key="phx_example"
+        ) as evaluations:
+            with patch.object(
+                evaluations._transport, "request", return_value=dataset_response()
+            ):
+                snapshot = evaluations.datasets.snapshot(DATASET_ID)
+        return list(snapshot.iter_items())
+
+    with pytest.raises(EvaluationAPIError) as caught:
+        asyncio.run(run_async()) if asynchronous else run_sync()
+    assert caught.value.code == "client_closed"
+    assert caught.value.persistence == "not_sent"
diff --git a/posthog/test/ai/test_evaluations_scorers.py b/posthog/test/ai/test_evaluations_scorers.py
index 9fa40e918..54cf97bac 100644
--- a/posthog/test/ai/test_evaluations_scorers.py
+++ b/posthog/test/ai/test_evaluations_scorers.py
@@ -214,7 +214,7 @@ def test_invalid_scorer_response_tags_raise(scorers, tags):
 
 
 @pytest.mark.parametrize("tag_match", ["any", "all"])
-@pytest.mark.parametrize("tags", [[], ("quality", 'a,b"c', "品質")])
+@pytest.mark.parametrize("tags", [None, [], ("quality", 'a,b"c', "品質")])
 def test_scorer_list_tag_filters_use_json_and_preserve_other_filters(
     scorers, tags, tag_match
 ):
@@ -229,8 +229,14 @@ def test_scorer_list_tag_filters_use_json_and_preserve_other_filters(
         namespace.list, tags=tags, tag_match=tag_match, offset=3, search="score"
     )
     params = transport.request.call_args.kwargs["params"]
-    assert json.loads(params["tags"]) == list(tags)
-    assert params["tag_match"] == tag_match
+    if tags is None:
+        assert "tags" not in params
+    else:
+        assert json.loads(params["tags"]) == list(tags)
+    if tags is None and tag_match == "any":
+        assert "tag_match" not in params
+    else:
+        assert params["tag_match"] == tag_match
     assert params["offset"] == 3
     assert params["search"] == "score"
     assert page.results[0].tags == ("quality",)
@@ -418,6 +424,8 @@ def test_malformed_success_preserves_unknown_persistence(scorers, override):
         )
     assert caught.value.code == "invalid_response"
     assert caught.value.persistence == "unknown"
+    assert caught.value.detail == "The scorer API returned an invalid response."
+    assert caught.value.response == transport.request.return_value
     assert "Quality" not in str(caught.value)
     transport.request.assert_called_once()
 
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 5a093b650..537e028f2 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -392,9 +392,13 @@ attribute posthog.ai.anthropic.anthropic_providers.AsyncAnthropicBedrock.message
 attribute posthog.ai.anthropic.anthropic_providers.AsyncAnthropicVertex.messages = AsyncWrappedMessages(self)
 attribute posthog.ai.claude_agent_sdk.client.log = logging.getLogger('posthog')
 attribute posthog.ai.claude_agent_sdk.processor.log = logging.getLogger('posthog')
+attribute posthog.ai.evaluations.AsyncDatasetSnapshot.dataset: Dataset
+attribute posthog.ai.evaluations.AsyncDatasetSnapshot.revision: int
+attribute posthog.ai.evaluations.AsyncDatasetSnapshot.revision_id: str
 attribute posthog.ai.evaluations.AsyncExperiment.id: str
 attribute posthog.ai.evaluations.AsyncExperiment.receipt = receipt
 attribute posthog.ai.evaluations.AsyncExperiment.submission: dict[str, Any] | None
+attribute posthog.ai.evaluations.AsyncOfflineEvaluations.datasets = AsyncDatasets(self._transport, project_id)
 attribute posthog.ai.evaluations.AsyncOfflineEvaluations.scorers = AsyncScorers(self._transport, project_id)
 attribute posthog.ai.evaluations.BooleanScorerConfig.false_label: str
 attribute posthog.ai.evaluations.BooleanScorerConfig.true_is_failure: bool | None
@@ -412,6 +416,58 @@ attribute posthog.ai.evaluations.CategoricalScorerConfig.passing_rule: Categoric
 attribute posthog.ai.evaluations.CategoricalScorerConfig.selection_mode: Literal['single', 'multiple']
 attribute posthog.ai.evaluations.CategoricalScorerOption.key: str
 attribute posthog.ai.evaluations.CategoricalScorerOption.label: str
+attribute posthog.ai.evaluations.Dataset.archived: bool
+attribute posthog.ai.evaluations.Dataset.created_at: datetime
+attribute posthog.ai.evaluations.Dataset.created_by: dict[str, Any] | None
+attribute posthog.ai.evaluations.Dataset.current_revision: int | None
+attribute posthog.ai.evaluations.Dataset.current_revision_id: str | None
+attribute posthog.ai.evaluations.Dataset.description: str
+attribute posthog.ai.evaluations.Dataset.id: str
+attribute posthog.ai.evaluations.Dataset.metadata: dict[str, JSONValue] = field(repr=False)
+attribute posthog.ai.evaluations.Dataset.name: str
+attribute posthog.ai.evaluations.Dataset.tags: tuple[str, ...]
+attribute posthog.ai.evaluations.Dataset.team_id: int
+attribute posthog.ai.evaluations.Dataset.updated_at: datetime | None
+attribute posthog.ai.evaluations.DatasetItem.archived: bool
+attribute posthog.ai.evaluations.DatasetItem.client_item_id: str | None
+attribute posthog.ai.evaluations.DatasetItem.created_at: datetime
+attribute posthog.ai.evaluations.DatasetItem.created_by: dict[str, Any] | None
+attribute posthog.ai.evaluations.DatasetItem.dataset_id: str
+attribute posthog.ai.evaluations.DatasetItem.dataset_revision: int
+attribute posthog.ai.evaluations.DatasetItem.dataset_revision_id: str
+attribute posthog.ai.evaluations.DatasetItem.expected_output: JSONValue = field(repr=False)
+attribute posthog.ai.evaluations.DatasetItem.id: str
+attribute posthog.ai.evaluations.DatasetItem.input: JSONValue = field(repr=False)
+attribute posthog.ai.evaluations.DatasetItem.metadata: dict[str, JSONValue] = field(repr=False)
+attribute posthog.ai.evaluations.DatasetItem.source_event_id: str | None
+attribute posthog.ai.evaluations.DatasetItem.source_output: JSONValue = field(repr=False)
+attribute posthog.ai.evaluations.DatasetItem.source_timestamp: datetime | None
+attribute posthog.ai.evaluations.DatasetItem.source_trace_id: str | None
+attribute posthog.ai.evaluations.DatasetItem.team_id: int
+attribute posthog.ai.evaluations.DatasetItem.updated_at: datetime | None
+attribute posthog.ai.evaluations.DatasetItem.version: int
+attribute posthog.ai.evaluations.DatasetItem.version_created_at: datetime
+attribute posthog.ai.evaluations.DatasetItem.version_created_by: dict[str, Any] | None
+attribute posthog.ai.evaluations.DatasetItem.version_id: str
+attribute posthog.ai.evaluations.DatasetItemPage.count: int
+attribute posthog.ai.evaluations.DatasetItemPage.next_offset: int | None
+attribute posthog.ai.evaluations.DatasetItemPage.results: tuple[DatasetItem, ...]
+attribute posthog.ai.evaluations.DatasetOrder = Literal['created_at', '-created_at', 'updated_at', '-updated_at']
+attribute posthog.ai.evaluations.DatasetPage.count: int
+attribute posthog.ai.evaluations.DatasetPage.next_offset: int | None
+attribute posthog.ai.evaluations.DatasetPage.results: tuple[Dataset, ...]
+attribute posthog.ai.evaluations.DatasetRevision.created_at: datetime
+attribute posthog.ai.evaluations.DatasetRevision.created_by: dict[str, Any] | None
+attribute posthog.ai.evaluations.DatasetRevision.dataset_id: str
+attribute posthog.ai.evaluations.DatasetRevision.id: str
+attribute posthog.ai.evaluations.DatasetRevision.revision: int
+attribute posthog.ai.evaluations.DatasetRevision.team_id: int
+attribute posthog.ai.evaluations.DatasetRevisionPage.count: int
+attribute posthog.ai.evaluations.DatasetRevisionPage.next_offset: int | None
+attribute posthog.ai.evaluations.DatasetRevisionPage.results: tuple[DatasetRevision, ...]
+attribute posthog.ai.evaluations.DatasetSnapshot.dataset: Dataset
+attribute posthog.ai.evaluations.DatasetSnapshot.revision: int
+attribute posthog.ai.evaluations.DatasetSnapshot.revision_id: str
 attribute posthog.ai.evaluations.EvaluationAPIError.attr = attr
 attribute posthog.ai.evaluations.EvaluationAPIError.code = code
 attribute posthog.ai.evaluations.EvaluationAPIError.detail = deepcopy(detail)
@@ -461,6 +517,7 @@ attribute posthog.ai.evaluations.NumericScorerConfig.max: float | None
 attribute posthog.ai.evaluations.NumericScorerConfig.min: float | None
 attribute posthog.ai.evaluations.NumericScorerConfig.passing_rule: NumericPassingRule | None
 attribute posthog.ai.evaluations.NumericScorerConfig.step: float | None
+attribute posthog.ai.evaluations.OfflineEvaluations.datasets = Datasets(self._transport, project_id)
 attribute posthog.ai.evaluations.OfflineEvaluations.scorers = Scorers(self._transport, project_id)
 attribute posthog.ai.evaluations.ResultOptions.error_code: str | None
 attribute posthog.ai.evaluations.ResultOptions.error_message: str | None
@@ -1128,6 +1185,8 @@ class posthog.ai.anthropic.anthropic_providers.AsyncAnthropicBedrock(posthog_cli
 class posthog.ai.anthropic.anthropic_providers.AsyncAnthropicVertex(posthog_client: Optional[PostHogClient] = None, **kwargs)
 class posthog.ai.claude_agent_sdk.client.PostHogClaudeSDKClient(options: Optional[ClaudeAgentOptions] = None, transport: Any = None, *, posthog_client: Optional[Client] = None, posthog_distinct_id: Optional[Union[str, Callable[[ResultMessage], Optional[str]]]] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: bool = False, posthog_groups: Optional[Dict[str, Any]] = None)
 class posthog.ai.claude_agent_sdk.processor.PostHogClaudeAgentProcessor(client: Optional[Client] = None, distinct_id: Optional[Union[str, Callable[[ResultMessage], Optional[str]]]] = None, privacy_mode: bool = False, groups: Optional[Dict[str, Any]] = None, properties: Optional[Dict[str, Any]] = None)
+class posthog.ai.evaluations.AsyncDatasetSnapshot(dataset: Dataset, revision: int, revision_id: str, _datasets: AsyncDatasets)
+class posthog.ai.evaluations.AsyncDatasets(transport: AsyncTransport, project_id: int)
 class posthog.ai.evaluations.AsyncExperiment(transport: AsyncTransport, project_id: int, id: str, *, receipt: ExperimentReceipt | None = None, submission: bytes | None = None)
 class posthog.ai.evaluations.AsyncOfflineEvaluations(*, project_id: int, secret_key: str, host: str | None = None, timeout: float = 15, max_retries: int = 3)
 class posthog.ai.evaluations.AsyncScorers(transport: AsyncTransport, project_id: int)
@@ -1137,6 +1196,14 @@ class posthog.ai.evaluations.BulkUploadReceipt(chunks: tuple[UploadReceipt, ...]
 class posthog.ai.evaluations.CategoricalPassingRule
 class posthog.ai.evaluations.CategoricalScorerConfig
 class posthog.ai.evaluations.CategoricalScorerOption
+class posthog.ai.evaluations.Dataset(id: str, name: str, description: str, metadata: dict[str, JSONValue], tags: tuple[str, ...], archived: bool, current_revision: int | None, current_revision_id: str | None, created_at: datetime, updated_at: datetime | None, created_by: dict[str, Any] | None, team_id: int)
+class posthog.ai.evaluations.DatasetItem(id: str, dataset_id: str, client_item_id: str | None, version: int, version_id: str, dataset_revision: int, dataset_revision_id: str, archived: bool, input: JSONValue, expected_output: JSONValue, source_output: JSONValue, metadata: dict[str, JSONValue], source_trace_id: str | None, source_event_id: str | None, source_timestamp: datetime | None, created_at: datetime, updated_at: datetime | None, created_by: dict[str, Any] | None, version_created_at: datetime, version_created_by: dict[str, Any] | None, team_id: int)
+class posthog.ai.evaluations.DatasetItemPage(count: int, results: tuple[DatasetItem, ...], next_offset: int | None)
+class posthog.ai.evaluations.DatasetPage(count: int, results: tuple[Dataset, ...], next_offset: int | None)
+class posthog.ai.evaluations.DatasetRevision(id: str, dataset_id: str, revision: int, created_at: datetime, created_by: dict[str, Any] | None, team_id: int)
+class posthog.ai.evaluations.DatasetRevisionPage(count: int, results: tuple[DatasetRevision, ...], next_offset: int | None)
+class posthog.ai.evaluations.DatasetSnapshot(dataset: Dataset, revision: int, revision_id: str, _datasets: Datasets)
+class posthog.ai.evaluations.Datasets(transport: SyncTransport, project_id: int)
 class posthog.ai.evaluations.EvaluationAPIError(*, status: int | None = None, code: str | None = None, detail: Any = None, attr: str | None = None, errors: Any = None, response: dict[str, Any] | None = None, retry_after: float | None = None, persistence: Literal['rejected', 'unknown', 'not_sent'] = 'unknown', submission: dict[str, Any] | None = None)
 class posthog.ai.evaluations.EvaluationItem(*, id: str | UUID | None = None, input: JSONValue | _Unset = _UNSET, output: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | None | _Unset = _UNSET, case_key: str | None = None, trial: str | None = None, dataset_item_identifier: str | None = None, dataset_item_version_identifier: str | None = None, dataset_item_version_id: str | UUID | None = None, application_trace_id: str | None = None, payload: dict[str, JSONValue] | _Unset = _UNSET)
 class posthog.ai.evaluations.EvaluationResult(*, item: EvaluationItem | str | UUID, scorer_version_id: str | UUID, value: ScoreValue | None = None, status: ResultStatus = 'ok', error_code: str | None = None, reasoning: str | None | _Unset = _UNSET, error_message: str | None | _Unset = _UNSET, metadata: dict[str, JSONValue] | None | _Unset = _UNSET, evaluator_trace_id: str | None = None, evaluated_at: datetime | str | None = None, payload: dict[str, JSONValue] | _Unset = _UNSET)
@@ -1501,6 +1568,22 @@ method posthog.ai.claude_agent_sdk.client.PostHogClaudeSDKClient.receive_respons
 method posthog.ai.claude_agent_sdk.client.PostHogClaudeSDKClient.set_model(model: Optional[str] = None) -> None
 method posthog.ai.claude_agent_sdk.client.PostHogClaudeSDKClient.set_permission_mode(mode: str) -> None
 method posthog.ai.claude_agent_sdk.processor.PostHogClaudeAgentProcessor.query(*, prompt: Any, options: Optional[ClaudeAgentOptions] = None, transport: Any = None, posthog_distinct_id: Optional[Union[str, Callable[[ResultMessage], Optional[str]]]] = None, posthog_trace_id: Optional[str] = None, posthog_properties: Optional[Dict[str, Any]] = None, posthog_privacy_mode: Optional[bool] = None, posthog_groups: Optional[Dict[str, Any]] = None)
+method posthog.ai.evaluations.AsyncDatasetSnapshot.iter_items(*, page_size: int = 25)
+method posthog.ai.evaluations.AsyncDatasets.archive(dataset_id: str | UUID)
+method posthog.ai.evaluations.AsyncDatasets.archive_item(item_id: str | UUID, *, base_version: int)
+method posthog.ai.evaluations.AsyncDatasets.create(*, name: str, description: str | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, tags: Sequence[str] | _Unset = _UNSET)
+method posthog.ai.evaluations.AsyncDatasets.create_item(dataset_id: str | UUID, *, input: JSONValue, expected_output: JSONValue | _Unset = _UNSET, source_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, client_item_id: str | None = None, source_trace_id: str | None = None, source_event_id: str | None = None, source_timestamp: datetime | str | None = None)
+method posthog.ai.evaluations.AsyncDatasets.get(dataset_id: str | UUID)
+method posthog.ai.evaluations.AsyncDatasets.get_item(item_id: str | UUID, *, revision: int | None = None)
+method posthog.ai.evaluations.AsyncDatasets.list(*, limit: int = 50, offset: int = 0, search: str | None = None, archived: bool = False, order_by: DatasetOrder = '-created_at', tags: Sequence[str] | None = None, tag_match: Literal['any', 'all'] = 'any')
+method posthog.ai.evaluations.AsyncDatasets.list_item_versions(item_id: str | UUID, *, limit: int = 25, offset: int = 0)
+method posthog.ai.evaluations.AsyncDatasets.list_items(dataset_id: str | UUID, *, revision: int | None = None, archived: bool = False, limit: int = 25, offset: int = 0)
+method posthog.ai.evaluations.AsyncDatasets.list_revisions(dataset_id: str | UUID, *, limit: int = 50, offset: int = 0)
+method posthog.ai.evaluations.AsyncDatasets.restore(dataset_id: str | UUID)
+method posthog.ai.evaluations.AsyncDatasets.restore_item(item_id: str | UUID, *, base_version: int, source_version: int | None = None)
+method posthog.ai.evaluations.AsyncDatasets.snapshot(dataset_id: str | UUID, *, revision: int | None = None)
+method posthog.ai.evaluations.AsyncDatasets.update(dataset_id: str | UUID, *, name: str | _Unset = _UNSET, description: str | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, tags: Sequence[str] | _Unset = _UNSET)
+method posthog.ai.evaluations.AsyncDatasets.update_item(item_id: str | UUID, *, base_version: int, input: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET)
 method posthog.ai.evaluations.AsyncExperiment.complete()
 method posthog.ai.evaluations.AsyncExperiment.fail()
 method posthog.ai.evaluations.AsyncExperiment.get_tags()
@@ -1517,6 +1600,23 @@ method posthog.ai.evaluations.AsyncScorers.get_version(scorer_id: str | UUID, ve
 method posthog.ai.evaluations.AsyncScorers.list(*, limit: int = 100, offset: int = 0, search: str | None = None, kind: ScorerKind | None = None, archived: bool | None = None, order_by: ScorerOrder | None = None, tags: Sequence[str] | None = None, tag_match: Literal['any', 'all'] = 'any')
 method posthog.ai.evaluations.AsyncScorers.list_versions(scorer_id: str | UUID, *, limit: int = 50, cursor: str | None = None)
 method posthog.ai.evaluations.AsyncScorers.update(scorer_id: str | UUID, *, name: str | _Omitted = _OMITTED, description: str | None | _Omitted = _OMITTED, archived: bool | _Omitted = _OMITTED, tags: Sequence[str] | _Omitted = _OMITTED)
+method posthog.ai.evaluations.DatasetSnapshot.iter_items(*, page_size: int = 25)
+method posthog.ai.evaluations.Datasets.archive(dataset_id: str | UUID)
+method posthog.ai.evaluations.Datasets.archive_item(item_id: str | UUID, *, base_version: int)
+method posthog.ai.evaluations.Datasets.create(*, name: str, description: str | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, tags: Sequence[str] | _Unset = _UNSET)
+method posthog.ai.evaluations.Datasets.create_item(dataset_id: str | UUID, *, input: JSONValue, expected_output: JSONValue | _Unset = _UNSET, source_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, client_item_id: str | None = None, source_trace_id: str | None = None, source_event_id: str | None = None, source_timestamp: datetime | str | None = None)
+method posthog.ai.evaluations.Datasets.get(dataset_id: str | UUID)
+method posthog.ai.evaluations.Datasets.get_item(item_id: str | UUID, *, revision: int | None = None)
+method posthog.ai.evaluations.Datasets.list(*, limit: int = 50, offset: int = 0, search: str | None = None, archived: bool = False, order_by: DatasetOrder = '-created_at', tags: Sequence[str] | None = None, tag_match: Literal['any', 'all'] = 'any')
+method posthog.ai.evaluations.Datasets.list_item_versions(item_id: str | UUID, *, limit: int = 25, offset: int = 0)
+method posthog.ai.evaluations.Datasets.list_items(dataset_id: str | UUID, *, revision: int | None = None, archived: bool = False, limit: int = 25, offset: int = 0)
+method posthog.ai.evaluations.Datasets.list_revisions(dataset_id: str | UUID, *, limit: int = 50, offset: int = 0)
+method posthog.ai.evaluations.Datasets.restore(dataset_id: str | UUID)
+method posthog.ai.evaluations.Datasets.restore_item(item_id: str | UUID, *, base_version: int, source_version: int | None = None)
+method posthog.ai.evaluations.Datasets.snapshot(dataset_id: str | UUID, *, revision: int | None = None)
+method posthog.ai.evaluations.Datasets.update(dataset_id: str | UUID, *, name: str | _Unset = _UNSET, description: str | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, tags: Sequence[str] | _Unset = _UNSET)
+method posthog.ai.evaluations.Datasets.update_item(item_id: str | UUID, *, base_version: int, input: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET)
+method posthog.ai.evaluations.EvaluationItem.from_dataset_item(item: DatasetItem, *, output: JSONValue | _Unset = _UNSET, id: str | UUID | None = None, case_key: str | None = None, trial: str | None = None, application_trace_id: str | None = None)
 method posthog.ai.evaluations.EvaluationItem.from_dict(data: Mapping[str, Any])
 method posthog.ai.evaluations.EvaluationItem.to_dict()
 method posthog.ai.evaluations.EvaluationResult.from_dict(data: Mapping[str, Any], *, item: EvaluationItem | None = None)

From ac7fa9955ce1dc6f2f11b0d36017eb65727624a1 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:39:33 +0000
Subject: [PATCH 063/245] chore: Release v7.74.0 [skip ci]

---
 .sampo/changesets/ai-evaluation-datasets.md | 5 -----
 openfeature-provider/CHANGELOG.md           | 6 ++++++
 openfeature-provider/pyproject.toml         | 2 +-
 posthog/CHANGELOG.md                        | 6 ++++++
 posthog/version.py                          | 2 +-
 pyproject.toml                              | 2 +-
 uv.lock                                     | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/ai-evaluation-datasets.md

diff --git a/.sampo/changesets/ai-evaluation-datasets.md b/.sampo/changesets/ai-evaluation-datasets.md
deleted file mode 100644
index 22d689b31..000000000
--- a/.sampo/changesets/ai-evaluation-datasets.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Manage AI observability datasets and items through `OfflineEvaluations.datasets` and `AsyncOfflineEvaluations.datasets`, including history, tags, and archive/restore operations. Pin a dataset snapshot for lazy, consistent reads and use `EvaluationItem.from_dataset_item()` to preserve case provenance across offline experiments and scorers. Item creates with a caller-supplied `client_item_id` support safe retries; updates use explicit version checks.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index eae14033a..eb45ccb44 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.113 — 2026-10-21
+
+### Patch changes
+
+- Updated dependencies: posthog@7.74.0
+
 ## 0.1.112 — 2026-10-21
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 89ebd7d48..923b64784 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.112"
+version = "0.1.113"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index ef5cff2d4..9b6467603 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.74.0 — 2026-10-21
+
+### Minor changes
+
+- [b8879a7](https://github.com/posthog/posthog-python/commit/b8879a7550e1bc2728bb5d23d8ddb215ba3602a7) Manage AI observability datasets and items through `OfflineEvaluations.datasets` and `AsyncOfflineEvaluations.datasets`, including history, tags, and archive/restore operations. Pin a dataset snapshot for lazy, consistent reads and use `EvaluationItem.from_dataset_item()` to preserve case provenance across offline experiments and scorers. Item creates with a caller-supplied `client_item_id` support safe retries; updates use explicit version checks. — Thanks @Radu-Raicea!
+
 ## 7.73.3 — 2026-10-21
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 94c1d369b..bf1e6fa9c 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.73.3"
+VERSION = "7.74.0"
diff --git a/pyproject.toml b/pyproject.toml
index aa7cc64c1..3997eb889 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.73.3"
+version = "7.74.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index bed4085a4..48f25f3c0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2542,7 +2542,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.112"
+version = "0.1.113"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -2872,7 +2872,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.3"
+version = "7.74.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From b14dd9e3f00c06af510e524379a4dea34572f4c9 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 14:39:38 +0000
Subject: [PATCH 064/245] Update generated references

---
 .../posthog-python-references-7.74.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.74.0.json

diff --git a/references/posthog-python-references-7.74.0.json b/references/posthog-python-references-7.74.0.json
new file mode 100644
index 000000000..2053aac41
--- /dev/null
+++ b/references/posthog-python-references-7.74.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.74.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 973a24408..2053aac41 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.73.3",
+    "version": "7.74.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 5f01fe93b893944f9b04c9e0f0536df46810143f Mon Sep 17 00:00:00 2001
From: Paul D'Ambra <paul.dambra@gmail.com>
Date: Wed, 21 Oct 2026 16:02:08 +0100
Subject: [PATCH 065/245] feat(django): add request context to OpenTelemetry
 spans (#1070)

* feat(django): add request context to OpenTelemetry spans

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* fix(tracing): preserve span attributes and active context values

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* chore: use current tracing header settings in span checks

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* fix(tracing): respect disabled context owners

Generated-By: PostHog Desktop
Task-Id: bfd18848-e498-4352-a58a-b9ba85de4198
---
 .sampo/changesets/django-otel-span-context.md |   5 +
 posthog/client.py                             |   6 +-
 posthog/contexts.py                           |  21 +-
 posthog/integrations/django.py                |   3 +
 posthog/integrations/otel.py                  |  30 ++
 .../test/integrations/test_otel_context.py    | 423 ++++++++++++++++++
 posthog/tracing/_context.py                   |  66 +++
 references/middleware_configuration.md        |  45 ++
 references/public_api_snapshot.txt            |   4 +
 9 files changed, 597 insertions(+), 6 deletions(-)
 create mode 100644 .sampo/changesets/django-otel-span-context.md
 create mode 100644 posthog/integrations/otel.py
 create mode 100644 posthog/test/integrations/test_otel_context.py
 create mode 100644 posthog/tracing/_context.py

diff --git a/.sampo/changesets/django-otel-span-context.md b/.sampo/changesets/django-otel-span-context.md
new file mode 100644
index 000000000..90a517cd3
--- /dev/null
+++ b/.sampo/changesets/django-otel-span-context.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add an optional OpenTelemetry span processor for PostHog request IDs and enrich active Django request spans after request context is available.
diff --git a/posthog/client.py b/posthog/client.py
index 1efb521e3..27fee5428 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -36,6 +36,7 @@
 from posthog.consumer import AI_MAX_MSG_SIZE, MAX_MSG_SIZE, Consumer, _DrainSignal
 from posthog.contexts import (
     _get_current_context,
+    _get_active_span_context,
     get_capture_exception_code_variables_context,
     get_code_variables_detect_secrets_context,
     get_code_variables_ignore_patterns_context,
@@ -2628,10 +2629,7 @@ def _traces_pipeline(self) -> Optional[PostHogTraces]:
     def _tracing_context(self) -> Dict[str, Optional[str]]:
         # The request context's identity, which the Django middleware fills
         # from the X-POSTHOG-* headers: the span's person/session join keys.
-        return {
-            "distinct_id": get_context_distinct_id(),
-            "session_id": get_context_session_id(),
-        }
+        return _get_active_span_context()
 
     def start_span(
         self,
diff --git a/posthog/contexts.py b/posthog/contexts.py
index f897d1d96..36ec8adaa 100644
--- a/posthog/contexts.py
+++ b/posthog/contexts.py
@@ -21,6 +21,7 @@ def __init__(
     ):
         self.client: Optional[Client] = client
         self._generation = _context_generation
+        self._span_context_active = True
         self.parent = parent
         self.fresh = fresh
         self.capture_exceptions = capture_exceptions
@@ -156,6 +157,20 @@ def _get_current_context() -> Optional[ContextScope]:
     return current_context
 
 
+def _get_active_span_context() -> Dict[str, Optional[str]]:
+    values: Dict[str, Optional[str]] = {"distinct_id": None, "session_id": None}
+    scope = _get_current_context()
+    while scope is not None and scope._span_context_active:
+        if values["distinct_id"] is None:
+            values["distinct_id"] = scope.distinct_id
+        if values["session_id"] is None:
+            values["session_id"] = scope.session_id
+        if scope.fresh:
+            break
+        scope = scope.parent
+    return values
+
+
 def _default_capture_exceptions(client: Optional["Client"] = None) -> bool:
     if client is not None:
         return client.enable_exception_autocapture
@@ -192,8 +207,9 @@ def new_context(
         client: Optional client instance to use for capturing exceptions (default: None).
                 If provided, the client will be used to capture exceptions within the context.
                 If not provided, the default (global) client will be used. Note that the passed
-                client is only used to capture exceptions within the context - other events captured
-                within the context via `Client.capture` or `posthog.capture` will still carry the context
+                client controls exception capture and OpenTelemetry ID enrichment within the context.
+                Nested span enrichment keeps the nearest supplied client, including in fresh scopes.
+                Other events captured via `Client.capture` or `posthog.capture` still carry the context
                 state (tags, identity, session id), but will be captured by the client directly used (or
                 the global one, in the case of `posthog.capture`)
 
@@ -245,6 +261,7 @@ def new_context(
                 capture_exception(e)
         raise
     finally:
+        new_context._span_context_active = False
         if context_generation == _context_generation:
             _context_stack.set(new_context.get_parent())
 
diff --git a/posthog/integrations/django.py b/posthog/integrations/django.py
index f241c6cb6..9c305a75c 100644
--- a/posthog/integrations/django.py
+++ b/posthog/integrations/django.py
@@ -2,6 +2,7 @@
 
 from .. import contexts
 from ..client import Client
+from ..tracing._context import _enrich_current_span
 from ..exception_utils import (
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
@@ -348,6 +349,7 @@ def __call__(self, request):
                 for k, v in self.extract_tags(request).items():
                     contexts.tag(k, v)
 
+                _enrich_current_span()
                 return self.get_response(request)
 
     async def __acall__(self, request):
@@ -368,6 +370,7 @@ async def __acall__(self, request):
             for k, v in (await self.aextract_tags(request)).items():
                 contexts.tag(k, v)
 
+            _enrich_current_span()
             return await self.get_response(request)
 
     def process_exception(self, request, exception):
diff --git a/posthog/integrations/otel.py b/posthog/integrations/otel.py
new file mode 100644
index 000000000..fec4b282c
--- /dev/null
+++ b/posthog/integrations/otel.py
@@ -0,0 +1,30 @@
+from typing import Optional
+
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import Span, SpanProcessor
+
+from ..tracing._context import _enrich_current_span, _enrich_span
+
+__all__ = ["PostHogContextSpanProcessor", "enrich_current_span"]
+
+
+def enrich_current_span() -> None:
+    """Add request IDs to an existing recording span after request context is set.
+
+    Explicit span attributes take precedence. Missing OpenTelemetry support and
+    context lookup failures do not interrupt request handling.
+    """
+    _enrich_current_span()
+
+
+class PostHogContextSpanProcessor(SpanProcessor):
+    """Add PostHog request IDs to application-owned OpenTelemetry SDK spans.
+
+    Add this processor to the application's existing TracerProvider before
+    starting requests. It snapshots child span context at span start, without
+    changing exporters, sampling or providers. Request integrations must also
+    enrich an incoming span that started before request context was available.
+    """
+
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
+        _enrich_span(span)
diff --git a/posthog/test/integrations/test_otel_context.py b/posthog/test/integrations/test_otel_context.py
new file mode 100644
index 000000000..a8aac9935
--- /dev/null
+++ b/posthog/test/integrations/test_otel_context.py
@@ -0,0 +1,423 @@
+import asyncio
+from contextlib import nullcontext
+from unittest.mock import patch
+
+import pytest
+from django.test import override_settings
+from opentelemetry.sdk.trace import SpanLimits, TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from posthog import contexts
+from posthog.integrations.django import PosthogContextMiddleware
+from posthog.integrations.otel import PostHogContextSpanProcessor, enrich_current_span
+from posthog.test.integrations.test_middleware import MockRequest
+from posthog.test.tracing.test_client_traces import (
+    make_client,
+    mock_session,
+    flush_and_capture,
+    spans_from,
+)
+
+
+@pytest.fixture
+def tracing(monkeypatch):
+    monkeypatch.setattr("posthog.project_api_key", "phc_key")
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(PostHogContextSpanProcessor())
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    yield provider.get_tracer(__name__), exporter
+    provider.shutdown()
+
+
+@pytest.fixture
+def native_client():
+    client = make_client(traces={})
+    with patch("posthog.tracing._transport._get_session", return_value=mock_session()):
+        yield client
+        client.shutdown()
+
+
+@pytest.mark.parametrize(
+    "attributes,expected",
+    [
+        ({}, {"sessionId": "session", "posthogDistinctId": "person"}),
+        (
+            {"sessionId": "own-session", "posthogDistinctId": "own-person"},
+            {"sessionId": "own-session", "posthogDistinctId": "own-person"},
+        ),
+        (
+            {"user.id": "authenticated"},
+            {"user.id": "authenticated", "sessionId": "session"},
+        ),
+    ],
+)
+def test_child_span_snapshots_context_and_preserves_identity(
+    tracing, attributes, expected
+):
+    tracer, exporter = tracing
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        contexts.identify_context("person")
+        contexts.set_context_session("session")
+        span = tracer.start_span("child", attributes=attributes)
+        contexts.identify_context("later-person")
+        contexts.set_context_session("later-session")
+    span.end()
+    assert dict(exporter.get_finished_spans()[0].attributes) == expected
+
+
+@pytest.mark.parametrize("disabled", [False, True])
+@pytest.mark.parametrize(
+    "owner",
+    ["scope", "inherited", "fresh", "global-client", "global-setting", "global-no-key"],
+)
+def test_enrichment_respects_owning_client_disabled_state(
+    tracing, monkeypatch, owner, disabled
+):
+    tracer, exporter = tracing
+    client = make_client(send=False, disabled=disabled)
+    monkeypatch.setattr(
+        "posthog.default_client", client if owner == "global-client" else None
+    )
+    monkeypatch.setattr(
+        "posthog.disabled",
+        disabled
+        if owner in {"global-setting", "global-no-key"}
+        else owner in {"scope", "inherited", "fresh"} and not disabled,
+    )
+    monkeypatch.setattr("posthog.api_key", None)
+    monkeypatch.setattr(
+        "posthog.project_api_key", "phc_key" if owner == "global-setting" else " "
+    )
+    disabled = disabled or owner == "global-no-key"
+    try:
+        with contexts.new_context(
+            fresh=True,
+            capture_exceptions=False,
+            client=client if owner in {"scope", "inherited", "fresh"} else None,
+        ):
+            nested = (
+                contexts.new_context(fresh=owner == "fresh", capture_exceptions=False)
+                if owner in {"inherited", "fresh"}
+                else nullcontext()
+            )
+            with (
+                nested,
+                tracer.start_as_current_span(
+                    "request", attributes={"posthogDistinctId": "application-person"}
+                ),
+            ):
+                contexts.identify_context("person")
+                contexts.set_context_session("session")
+                enrich_current_span()
+                tracer.start_span("child", attributes={"app.key": "keep"}).end()
+    finally:
+        client.shutdown()
+    spans = {span.name: dict(span.attributes) for span in exporter.get_finished_spans()}
+    assert spans["request"] == {"posthogDistinctId": "application-person"} | (
+        {} if disabled else {"sessionId": "session"}
+    )
+    assert spans["child"] == {"app.key": "keep"} | (
+        {} if disabled else {"posthogDistinctId": "person", "sessionId": "session"}
+    )
+
+
+@pytest.mark.parametrize("outer_disabled", [False, True])
+def test_explicit_client_owns_fresh_nested_enrichment(
+    tracing, monkeypatch, outer_disabled
+):
+    tracer, exporter = tracing
+    outer = make_client(send=False, disabled=outer_disabled)
+    inner = make_client(send=False, disabled=not outer_disabled)
+    monkeypatch.setattr("posthog.default_client", outer)
+    monkeypatch.setattr("posthog.disabled", outer_disabled)
+    try:
+        with contexts.new_context(fresh=True, client=outer, capture_exceptions=False):
+            contexts.identify_context("outer-person")
+            with contexts.new_context(
+                fresh=True, client=inner, capture_exceptions=False
+            ):
+                contexts.identify_context("inner-person")
+                contexts.set_context_session("inner-session")
+                tracer.start_span("child").end()
+    finally:
+        inner.shutdown()
+        outer.shutdown()
+    assert dict(exporter.get_finished_spans()[0].attributes) == (
+        {"posthogDistinctId": "inner-person", "sessionId": "inner-session"}
+        if outer_disabled
+        else {}
+    )
+
+
+@pytest.mark.parametrize("initially_disabled", [False, True])
+def test_enrichment_observes_runtime_disabled_changes(tracing, initially_disabled):
+    tracer, exporter = tracing
+    client = make_client(send=False, disabled=initially_disabled)
+    try:
+        with contexts.new_context(fresh=True, client=client, capture_exceptions=False):
+            contexts.identify_context("person")
+            contexts.set_context_session("session")
+            before = tracer.start_span("before")
+            client.disabled = True
+            with tracer.start_as_current_span(
+                "disabled", attributes={"sessionId": "application-session"}
+            ):
+                enrich_current_span()
+                tracer.start_span("disabled-child").end()
+            client.disabled = False
+            tracer.start_span("enabled").end()
+            before.end()
+    finally:
+        client.shutdown()
+    spans = {span.name: dict(span.attributes) for span in exporter.get_finished_spans()}
+    ids = {"posthogDistinctId": "person", "sessionId": "session"}
+    assert spans["before"] == ({} if initially_disabled else ids)
+    assert spans["disabled"] == {"sessionId": "application-session"}
+    assert spans["disabled-child"] == {}
+    assert spans["enabled"] == ids
+
+
+@pytest.mark.parametrize("failure", [ImportError("optional"), RuntimeError("lookup")])
+def test_current_span_lookup_failure_does_not_escape(failure):
+    with patch("opentelemetry.trace.get_current_span", side_effect=failure):
+        enrich_current_span()
+
+
+def test_no_context_omits_identifiers(tracing):
+    tracer, exporter = tracing
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        tracer.start_span("unlinked").end()
+    assert dict(exporter.get_finished_spans()[0].attributes) == {}
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("fail", [False, True])
+def test_django_enriches_existing_request_and_child_spans(
+    tracing, native_client, asynchronous, fail
+):
+    tracer, exporter = tracing
+
+    def view(request):
+        native_client.start_span("native").end()
+        tracer.start_span("child").end()
+        if fail:
+            raise ValueError("view failed")
+        return "response"
+
+    async def async_view(request):
+        return view(request)
+
+    async def run_async(middleware, request):
+        with tracer.start_as_current_span("request"):
+            return await middleware(request)
+
+    request = MockRequest(
+        headers={
+            "X-POSTHOG-DISTINCT-ID": "browser-person",
+            "X-POSTHOG-SESSION-ID": "browser-session",
+        }
+    )
+    with (
+        override_settings(
+            POSTHOG_MW_CAPTURE_EXCEPTIONS=False, POSTHOG_MW_CAPTURE_TRACING_HEADERS=True
+        ),
+        contexts.new_context(fresh=True, capture_exceptions=False),
+    ):
+        middleware = PosthogContextMiddleware(async_view if asynchronous else view)
+        with pytest.raises(ValueError) if fail else nullcontext():
+            if asynchronous:
+                asyncio.run(run_async(middleware, request))
+            else:
+                with tracer.start_as_current_span("request"):
+                    middleware(request)
+        assert contexts.get_context_distinct_id() is None
+        assert contexts.get_context_session_id() is None
+        tracer.start_span("after-request").end()
+    spans = {span.name: span for span in exporter.get_finished_spans()}
+    for name in ("request", "child"):
+        assert dict(spans[name].attributes) == {
+            "posthogDistinctId": "browser-person",
+            "sessionId": "browser-session",
+        }
+    assert dict(spans["after-request"].attributes) == {}
+    payload, _, _ = flush_and_capture(native_client)
+    (native,) = spans_from(payload)
+    assert {
+        attribute["key"]: attribute["value"]["stringValue"]
+        for attribute in native["attributes"]
+    } == {
+        "posthogDistinctId": "browser-person",
+        "sessionId": "browser-session",
+    }
+
+
+def test_async_django_requests_keep_separate_span_context(tracing):
+    tracer, exporter = tracing
+    both_started = asyncio.Event()
+    started = 0
+
+    async def view(request):
+        nonlocal started
+        started += 1
+        if started == 2:
+            both_started.set()
+        await both_started.wait()
+        tracer.start_span(request.path + "-child").end()
+        return "response"
+
+    async def run_request(middleware, identity):
+        request = MockRequest(
+            path=identity,
+            headers={
+                "X-POSTHOG-DISTINCT-ID": identity,
+                "X-POSTHOG-SESSION-ID": identity + "-session",
+            },
+        )
+        with tracer.start_as_current_span(identity):
+            await middleware(request)
+
+    async def run():
+        await asyncio.gather(
+            *(run_request(middleware, identity) for identity in ("one", "two"))
+        )
+
+    with override_settings(
+        POSTHOG_MW_CAPTURE_EXCEPTIONS=False, POSTHOG_MW_CAPTURE_TRACING_HEADERS=True
+    ):
+        middleware = PosthogContextMiddleware(view)
+        asyncio.run(run())
+    for span in exporter.get_finished_spans():
+        identity = span.name.split("-")[0]
+        assert dict(span.attributes) == {
+            "posthogDistinctId": identity,
+            "sessionId": identity + "-session",
+        }
+
+
+def test_context_lookup_failure_does_not_break_span_creation(tracing):
+    tracer, exporter = tracing
+    with patch.object(
+        contexts, "_get_active_span_context", side_effect=RuntimeError("context")
+    ):
+        tracer.start_span("child").end()
+    assert len(exporter.get_finished_spans()) == 1
+    assert dict(exporter.get_finished_spans()[0].attributes) == {}
+
+
+@pytest.mark.parametrize("nested", [False, True])
+@pytest.mark.parametrize(
+    "own_ids",
+    [
+        {},
+        {"distinct_id": "background-person"},
+        {"session_id": "background-session"},
+        {"distinct_id": "background-person", "session_id": "background-session"},
+    ],
+)
+def test_spans_started_after_django_request_do_not_use_inherited_ids(
+    tracing, native_client, nested, own_ids
+):
+    tracer, exporter = tracing
+
+    async def run():
+        release = asyncio.Event()
+        tasks = []
+
+        async def late_work(held, native_held):
+            await release.wait()
+            with contexts.new_context() if nested else nullcontext():
+                if "distinct_id" in own_ids:
+                    contexts.identify_context(own_ids["distinct_id"])
+                if "session_id" in own_ids:
+                    contexts.set_context_session(own_ids["session_id"])
+                tracer.start_span("late").end()
+                native_client.start_span("native-late").end()
+                assert contexts.get_context_session_id() == own_ids.get(
+                    "session_id", "session"
+                )
+            held.end()
+            native_held.end()
+
+        async def view(request):
+            tasks.append(
+                asyncio.create_task(
+                    late_work(
+                        tracer.start_span("held"),
+                        native_client.start_span("native-held"),
+                    )
+                )
+            )
+            return "response"
+
+        middleware = PosthogContextMiddleware(view)
+        await middleware(
+            MockRequest(
+                headers={
+                    "X-POSTHOG-DISTINCT-ID": "person",
+                    "X-POSTHOG-SESSION-ID": "session",
+                }
+            )
+        )
+        release.set()
+        await asyncio.gather(*tasks)
+
+    with override_settings(
+        POSTHOG_MW_CAPTURE_EXCEPTIONS=False, POSTHOG_MW_CAPTURE_TRACING_HEADERS=True
+    ):
+        asyncio.run(run())
+    spans = {span.name: dict(span.attributes) for span in exporter.get_finished_spans()}
+    expected = {
+        key: own_ids[field]
+        for field, key in (
+            ("distinct_id", "posthogDistinctId"),
+            ("session_id", "sessionId"),
+        )
+        if nested and field in own_ids
+    }
+    assert spans["late"] == expected
+    assert spans["held"] == {"sessionId": "session", "posthogDistinctId": "person"}
+    payload, _, _ = flush_and_capture(native_client)
+    native = {span["name"]: span for span in spans_from(payload)}
+    assert {
+        attribute["key"]: attribute["value"]["stringValue"]
+        for attribute in native["native-late"].get("attributes", [])
+    } == expected
+    assert {
+        attribute["key"]: attribute["value"]["stringValue"]
+        for attribute in native["native-held"]["attributes"]
+    } == {
+        "sessionId": "session",
+        "posthogDistinctId": "person",
+    }
+
+
+@pytest.mark.parametrize("limit", [0, 1, 2, 3, 128])
+@pytest.mark.parametrize("current_span", [False, True])
+def test_enrichment_does_not_evict_application_attributes(
+    monkeypatch, limit, current_span
+):
+    monkeypatch.setattr("posthog.project_api_key", "phc_key")
+    provider = TracerProvider(span_limits=SpanLimits(max_span_attributes=limit))
+    provider.add_span_processor(PostHogContextSpanProcessor())
+    tracer = provider.get_tracer(__name__)
+    attributes = {"posthogDistinctId": "application-person", "other": "keep"}
+    baseline = tracer.start_span("baseline", attributes=attributes)
+    baseline.end()
+    try:
+        with contexts.new_context(fresh=True, capture_exceptions=False):
+            if not current_span:
+                contexts.set_context_session("session")
+            with tracer.start_as_current_span("span", attributes=attributes) as span:
+                if current_span:
+                    contexts.set_context_session("session")
+                    enrich_current_span()
+                retained = dict(list(attributes.items())[-limit:]) if limit else {}
+                expected = retained | (
+                    {"sessionId": "session"} if limit > len(attributes) else {}
+                )
+                assert dict(span.attributes) == expected
+                assert span.dropped_attributes == baseline.dropped_attributes
+    finally:
+        provider.shutdown()
diff --git a/posthog/tracing/_context.py b/posthog/tracing/_context.py
new file mode 100644
index 000000000..25c5299da
--- /dev/null
+++ b/posthog/tracing/_context.py
@@ -0,0 +1,66 @@
+import logging
+from collections.abc import Mapping
+
+from .. import contexts
+
+log = logging.getLogger("posthog")
+_IDENTITY_ATTRIBUTES = (
+    "posthogDistinctId",
+    "posthog.distinct_id",
+    "user.id",
+    "enduser.id",
+)
+
+
+def _enrichment_is_enabled() -> bool:
+    scope = contexts._get_current_context()
+    while scope is not None:
+        if scope.client is not None:
+            return not scope.client.disabled
+        scope = scope.parent
+
+    from .. import api_key, default_client, disabled, project_api_key
+
+    if disabled:
+        return False
+    if default_client is not None:
+        return not default_client.disabled
+    return bool((project_api_key or "").strip() or (api_key or "").strip())
+
+
+def _enrich_span(span: object) -> None:
+    try:
+        if not _enrichment_is_enabled() or not getattr(span, "is_recording")():
+            return
+        attributes = getattr(span, "attributes", None)
+        if not isinstance(attributes, Mapping):
+            return
+        context = contexts._get_active_span_context()
+        extra = {}
+        session_id = context["session_id"]
+        distinct_id = context["distinct_id"]
+        if session_id and "sessionId" not in attributes:
+            extra["sessionId"] = session_id
+        if distinct_id and not any(key in attributes for key in _IDENTITY_ATTRIBUTES):
+            extra["posthogDistinctId"] = distinct_id
+        if not extra:
+            return
+        # The SDK exposes no public capacity getter and evicts old attributes
+        # when full. Skip enrichment if its private limit is unavailable.
+        limit = getattr(getattr(span, "_limits", None), "max_span_attributes", None)
+        if not isinstance(limit, int) or len(attributes) + len(extra) > limit:
+            return
+        getattr(span, "set_attributes")(extra)
+    except Exception:
+        log.debug("Failed to add PostHog context to span", exc_info=True)
+
+
+def _enrich_current_span() -> None:
+    try:
+        from opentelemetry.trace import get_current_span
+
+        _enrich_span(get_current_span())
+    except ImportError:
+        pass
+    except Exception:
+        log.debug("Failed to read current OpenTelemetry span", exc_info=True)
diff --git a/references/middleware_configuration.md b/references/middleware_configuration.md
index 2a065adaa..70cc236e3 100644
--- a/references/middleware_configuration.md
+++ b/references/middleware_configuration.md
@@ -90,3 +90,48 @@ request scope it is restored. Background threads do not automatically inherit
 request context; async tasks follow Python's context-variable propagation rules.
 Flask isolates identity and request properties while retaining effective enclosing
 exception code-variable privacy controls.
+
+## OpenTelemetry spans
+
+Native PostHog spans read the active request IDs when `start_span` runs.
+For application-owned OpenTelemetry spans, install `opentelemetry-sdk` and add
+`PostHogContextSpanProcessor` to the application's existing `TracerProvider`:
+
+```python
+from posthog.integrations.otel import PostHogContextSpanProcessor
+
+provider.add_span_processor(PostHogContextSpanProcessor())
+```
+
+Register the processor before requests start. Keep the existing provider,
+exporters, and sampler. The processor adds `sessionId` and `posthogDistinctId`
+from the active PostHog context when each recording span starts. These values
+stay on the span after the request ends. Explicit span attributes take precedence.
+The bridge skips enrichment when there is not enough attribute capacity or the
+SDK does not expose its limit. OpenTelemetry SDK 1.20.0 or later is supported.
+An existing application identity, such as `user.id`, prevents fallback identity
+from being added. Absent IDs are omitted. OpenTelemetry remains optional for
+applications that do not use this integration.
+
+Django's `PosthogContextMiddleware` also adds IDs to the active OpenTelemetry SDK
+request span after it reads the request context. This covers a request span that
+starts before the PostHog middleware. Put the OpenTelemetry request middleware
+outside the PostHog middleware. Put Django's authentication middleware before
+PostHog if you want authenticated user identity. Both sync and async Django
+request handlers use the same bridge. Tracing headers are captured by default.
+Set `POSTHOG_MW_CAPTURE_TRACING_HEADERS = False` to disable extraction. These
+headers remain untrusted analytics context.
+
+For a custom request integration, call `enrich_current_span()` from
+`posthog.integrations.otel` once after setting the request IDs. This call handles
+an already active recording SDK span. The processor handles spans started later
+in the request. A context lookup failure does not interrupt the request.
+No provider, exporter, trace, session ID, or recording is created by this bridge.
+
+The bridge does not propagate context into a separate process or a new thread.
+Only spans started during the supported request lifetime inherit request IDs.
+Spans started by an inherited async task after the request ends omit request IDs.
+A background task can set its own IDs in a new `new_context()` scope.
+Only IDs from active scopes are used. Set `fresh=True` to prevent inheritance
+from any parent scope.
+The AI OpenTelemetry processor is a separate integration with different attributes.
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 537e028f2..c745fa8b6 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1292,6 +1292,7 @@ class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Opt
 class posthog.integrations.celery.PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
 class posthog.integrations.django.PosthogContextMiddleware(get_response)
 class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None)
+class posthog.integrations.otel.PostHogContextSpanProcessor 
 class posthog.mcp.McpAnalytics(key: Any)
 class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any)
 class posthog.mcp.constants.PostHogMCPAnalyticsEvent 
@@ -1498,6 +1499,7 @@ function posthog.identify_context(distinct_id: str)
 function posthog.integrations.django.markcoroutinefunction(func)
 function posthog.integrations.drf.create_exception_handler(handler: Optional[Callable[[Exception, Mapping[str, Any]], Any]] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, capture_4xx: bool = False, exception_filter: Optional[Callable[[Exception, Any, Mapping[str, Any]], bool]] = None) -> Callable[[Exception, Mapping[str, Any]], Any]
 function posthog.integrations.drf.exception_handler(exc: Exception, context: Mapping[str, Any]) -> Any
+function posthog.integrations.otel.enrich_current_span() -> None
 function posthog.join() -> None
 function posthog.load_feature_flags()
 function posthog.mcp.asgi.autowire_stateless_mint(server: Any) -> None
@@ -1802,6 +1804,7 @@ method posthog.integrations.django.PosthogContextMiddleware.extract_request_user
 method posthog.integrations.django.PosthogContextMiddleware.extract_tags(request)
 method posthog.integrations.django.PosthogContextMiddleware.process_exception(request, exception)
 method posthog.integrations.flask.PosthogFlaskIntegration.init_app(app: Flask) -> None
+method posthog.integrations.otel.PostHogContextSpanProcessor.on_start(span: Span, parent_context: Optional[Context] = None) -> None
 method posthog.mcp.McpAnalytics.capture(event: str, properties: Optional[dict] = None) -> None
 method posthog.mcp.McpAnalytics.flush() -> None
 method posthog.mcp.posthog_mcp.PostHogMCP.capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
@@ -1914,6 +1917,7 @@ module posthog.integrations.celery
 module posthog.integrations.django
 module posthog.integrations.drf
 module posthog.integrations.flask
+module posthog.integrations.otel
 module posthog.mcp
 module posthog.mcp.asgi
 module posthog.mcp.constants

From 5ddb4464a634a1dddf9b585cb9cf804c671a2edf Mon Sep 17 00:00:00 2001
From: Paul D'Ambra <paul.dambra@gmail.com>
Date: Wed, 21 Oct 2026 16:02:09 +0100
Subject: [PATCH 066/245] fix: enrich Flask, ASGI, and Celery spans with
 context (#1075)

* fix(flask): add request context to active OpenTelemetry spans

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* fix(asgi): enrich active request spans

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* fix(celery): enrich active task spans with job context

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* chore: use current tracing header settings in framework checks

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* fix(celery): preserve caller span identity during eager tasks

Generated-By: PostHog Desktop
Task-Id: 5681be44-4986-48db-b140-1bda88f75f96

* chore(tests): use enabled clients in span tests

Generated-By: PostHog Desktop
Task-Id: bfd18848-e498-4352-a58a-b9ba85de4198
---
 .sampo/changesets/asgi-otel-span-context.md   |   5 +
 .sampo/changesets/celery-otel-span-context.md |   5 +
 .sampo/changesets/flask-otel-span-context.md  |   5 +
 posthog/integrations/asgi.py                  |   3 +
 posthog/integrations/celery.py                |  20 ++
 posthog/integrations/flask.py                 |   3 +
 .../integrations/test_asgi_otel_context.py    | 247 +++++++++++++++
 .../integrations/test_celery_otel_context.py  | 238 ++++++++++++++
 posthog/test/integrations/test_flask_spans.py | 177 +++++++++++
 pyproject.toml                                |   3 +
 references/middleware_configuration.md        |  60 ++++
 uv.lock                                       | 293 ++++++++++++++++++
 12 files changed, 1059 insertions(+)
 create mode 100644 .sampo/changesets/asgi-otel-span-context.md
 create mode 100644 .sampo/changesets/celery-otel-span-context.md
 create mode 100644 .sampo/changesets/flask-otel-span-context.md
 create mode 100644 posthog/test/integrations/test_asgi_otel_context.py
 create mode 100644 posthog/test/integrations/test_celery_otel_context.py
 create mode 100644 posthog/test/integrations/test_flask_spans.py

diff --git a/.sampo/changesets/asgi-otel-span-context.md b/.sampo/changesets/asgi-otel-span-context.md
new file mode 100644
index 000000000..a3d821ea2
--- /dev/null
+++ b/.sampo/changesets/asgi-otel-span-context.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Add active PostHog request IDs to existing OpenTelemetry spans in ASGI middleware.
diff --git a/.sampo/changesets/celery-otel-span-context.md b/.sampo/changesets/celery-otel-span-context.md
new file mode 100644
index 000000000..0cb6c9285
--- /dev/null
+++ b/.sampo/changesets/celery-otel-span-context.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Add propagated task context to active Celery OpenTelemetry spans.
diff --git a/.sampo/changesets/flask-otel-span-context.md b/.sampo/changesets/flask-otel-span-context.md
new file mode 100644
index 000000000..fc475163a
--- /dev/null
+++ b/.sampo/changesets/flask-otel-span-context.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Add available PostHog request IDs to active Flask OpenTelemetry request spans.
diff --git a/posthog/integrations/asgi.py b/posthog/integrations/asgi.py
index 5d381c4c0..d58f818db 100644
--- a/posthog/integrations/asgi.py
+++ b/posthog/integrations/asgi.py
@@ -34,6 +34,7 @@
 
 from .. import contexts
 from ..client import Client
+from ..tracing._context import _enrich_current_span
 from ..exception_utils import (
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
@@ -249,6 +250,8 @@ async def __call__(self, scope, receive, send) -> None:
                 self.capture_tracing_headers,
             )
 
+            _enrich_current_span()
+
             properties = _extract_properties(scope, headers)
             if self.extra_properties:
                 extra_properties = await _resolve_callback_result(
diff --git a/posthog/integrations/celery.py b/posthog/integrations/celery.py
index 59a513be4..c11117922 100644
--- a/posthog/integrations/celery.py
+++ b/posthog/integrations/celery.py
@@ -67,6 +67,7 @@
 import json
 import logging
 import time
+from collections.abc import Mapping
 from typing import Any, Callable, Optional, cast
 
 from .. import contexts
@@ -75,6 +76,7 @@
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
 )
+from ..tracing._context import _enrich_span
 
 
 CONTEXT_DISTINCT_ID_HEADER = "X-POSTHOG-DISTINCT-ID"
@@ -309,6 +311,7 @@ def _on_task_prerun(self, *args, **kwargs):
                 request._posthog_start = time.monotonic()
 
             self._apply_propagated_identity(request)
+            self._enrich_task_span(task_id)
 
             merged_tags = {**task_properties, **context_tags}
             for key, value in merged_tags.items():
@@ -326,6 +329,23 @@ def _on_task_prerun(self, *args, **kwargs):
                 except Exception:
                     pass
 
+    @staticmethod
+    def _enrich_task_span(task_id: str) -> None:
+        try:
+            from opentelemetry.trace import get_current_span
+
+            span = get_current_span()
+            attributes = getattr(span, "attributes", None)
+            if (
+                isinstance(attributes, Mapping)
+                and attributes.get("celery.task_id") == task_id
+            ):
+                _enrich_span(span)
+        except ImportError:
+            pass
+        except Exception:
+            logger.debug("Failed to read current Celery task span", exc_info=True)
+
     def _on_task_success(self, *args, **kwargs):
         self._handle_task_end("success", **kwargs)
 
diff --git a/posthog/integrations/flask.py b/posthog/integrations/flask.py
index 8c416e5dc..345c37419 100644
--- a/posthog/integrations/flask.py
+++ b/posthog/integrations/flask.py
@@ -25,6 +25,7 @@
 
 from .. import contexts
 from ..client import Client
+from ..tracing._context import _enrich_current_span
 from ..exception_utils import (
     _ExceptionCaptureMetadata,
     _capture_exception_with_metadata,
@@ -201,6 +202,8 @@ def _before_request(self) -> None:
                 for key, value in extra_properties.items():
                     contexts.tag(key, value)
 
+        _enrich_current_span()
+
     @staticmethod
     def _request_properties(request: Request) -> dict[str, Any]:
         properties: dict[str, Any] = {
diff --git a/posthog/test/integrations/test_asgi_otel_context.py b/posthog/test/integrations/test_asgi_otel_context.py
new file mode 100644
index 000000000..2739eb830
--- /dev/null
+++ b/posthog/test/integrations/test_asgi_otel_context.py
@@ -0,0 +1,247 @@
+import asyncio
+from contextlib import nullcontext
+from unittest.mock import patch
+
+import pytest
+from fastapi import FastAPI
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from posthog import contexts
+from posthog.integrations.asgi import PosthogASGIMiddleware
+from posthog.integrations.otel import PostHogContextSpanProcessor
+from posthog.test.integrations.test_asgi_integration import (
+    http_scope,
+    noop_receive,
+    noop_send,
+)
+from posthog.test.tracing.test_client_traces import (
+    flush_and_capture,
+    make_client,
+    mock_session,
+    spans_from,
+)
+
+
+@pytest.fixture
+def tracing(monkeypatch):
+    monkeypatch.setattr("posthog.project_api_key", "phc_key")
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(PostHogContextSpanProcessor())
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    yield provider.get_tracer(__name__), exporter
+    provider.shutdown()
+
+
+@pytest.mark.parametrize("scope_type", ["http", "websocket"])
+@pytest.mark.parametrize(
+    "trust,headers,attributes,fail,expected",
+    [
+        (
+            True,
+            None,
+            {},
+            False,
+            {"sessionId": "session-123", "posthogDistinctId": "user-456"},
+        ),
+        (
+            True,
+            None,
+            {},
+            True,
+            {"sessionId": "session-123", "posthogDistinctId": "user-456"},
+        ),
+        (False, None, {}, False, {}),
+        (True, [], {}, False, {}),
+        (
+            True,
+            [(b"x-posthog-session-id", b"\x00\n"), (b"x-posthog-distinct-id", b"\t ")],
+            {},
+            False,
+            {},
+        ),
+        (
+            True,
+            None,
+            {"user.id": "authenticated"},
+            False,
+            {"user.id": "authenticated", "sessionId": "session-123"},
+        ),
+        (
+            True,
+            None,
+            {"sessionId": "explicit-session", "posthogDistinctId": "explicit-person"},
+            False,
+            {"sessionId": "explicit-session", "posthogDistinctId": "explicit-person"},
+        ),
+    ],
+)
+async def test_asgi_enriches_existing_request_and_child_spans(
+    tracing, scope_type, trust, headers, attributes, fail, expected
+):
+    tracer, exporter = tracing
+
+    async def app(scope, receive, send):
+        tracer.start_span("child", attributes=attributes).end()
+        if fail:
+            raise ValueError("handler failed")
+        await send(
+            {"type": "websocket.close"}
+            if scope_type == "websocket"
+            else {"type": "http.response.body", "body": b""}
+        )
+
+    scope = http_scope(type=scope_type)
+    if headers is not None:
+        scope["headers"] = headers
+    middleware = PosthogASGIMiddleware(
+        app, capture_exceptions=False, capture_tracing_headers=trust
+    )
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        with (
+            pytest.raises(ValueError, match="handler failed") if fail else nullcontext()
+        ):
+            with tracer.start_as_current_span("request", attributes=attributes):
+                await middleware(scope, noop_receive, noop_send)
+        assert contexts.get_context_session_id() is None
+        assert contexts.get_context_distinct_id() is None
+        tracer.start_span("after-request").end()
+
+    spans = {span.name: span for span in exporter.get_finished_spans()}
+    for name in ("request", "child"):
+        assert dict(spans[name].attributes) == expected
+    assert dict(spans["after-request"].attributes) == {}
+
+
+async def test_asgi_concurrent_requests_and_ended_task_context(tracing):
+    tracer, exporter = tracing
+    both_started = asyncio.Event()
+    finished = asyncio.Event()
+    held_spans = []
+    background_tasks = []
+
+    async def background(name):
+        await finished.wait()
+        tracer.start_span("late-" + name).end()
+
+    async def app(scope, receive, send):
+        name = scope["path"]
+        held_spans.append(tracer.start_span("held-" + name))
+        background_tasks.append(asyncio.create_task(background(name)))
+        if len(held_spans) == 2:
+            both_started.set()
+        await both_started.wait()
+        tracer.start_span("child-" + name).end()
+
+    middleware = PosthogASGIMiddleware(app, capture_tracing_headers=True)
+
+    async def request(name):
+        with tracer.start_as_current_span("request-" + name):
+            await middleware(
+                http_scope(
+                    path=name,
+                    headers=[
+                        (b"x-posthog-session-id", ("session-" + name).encode()),
+                        (b"x-posthog-distinct-id", ("person-" + name).encode()),
+                    ],
+                ),
+                noop_receive,
+                noop_send,
+            )
+
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        await asyncio.gather(request("first"), request("second"))
+        finished.set()
+        await asyncio.gather(*background_tasks)
+        for span in held_spans:
+            span.end()
+
+    spans = {span.name: span for span in exporter.get_finished_spans()}
+    for name in ("first", "second"):
+        for prefix in ("request-", "child-", "held-"):
+            assert dict(spans[prefix + name].attributes) == {
+                "sessionId": "session-" + name,
+                "posthogDistinctId": "person-" + name,
+            }
+        assert dict(spans["late-" + name].attributes) == {}
+
+
+@pytest.mark.parametrize("scope_type,filtered", [("http", True), ("lifespan", False)])
+async def test_asgi_bypassed_scopes_do_not_enrich_spans(tracing, scope_type, filtered):
+    tracer, exporter = tracing
+
+    async def app(scope, receive, send):
+        tracer.start_span("child").end()
+
+    middleware = PosthogASGIMiddleware(
+        app,
+        capture_tracing_headers=True,
+        request_filter=(lambda scope: False) if filtered else None,
+    )
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        with tracer.start_as_current_span("request"):
+            await middleware(http_scope(type=scope_type), noop_receive, noop_send)
+    assert all(dict(span.attributes) == {} for span in exporter.get_finished_spans())
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("fail", [False, True])
+async def test_fastapi_sync_and_async_handlers_enrich_native_and_otel_spans(
+    tracing, asynchronous, fail
+):
+    tracer, exporter = tracing
+    native = make_client(traces={})
+
+    def handler():
+        native.start_span("native").end()
+        tracer.start_span("child").end()
+        if fail:
+            raise ValueError("handler failed")
+        return {"ok": True}
+
+    async def async_handler():
+        return handler()
+
+    app = FastAPI()
+    app.add_api_route("/api/items", async_handler if asynchronous else handler)
+    app.add_middleware(
+        PosthogASGIMiddleware, capture_tracing_headers=True, capture_exceptions=False
+    )
+    responses = []
+
+    async def send(message):
+        responses.append(message)
+
+    try:
+        with (
+            patch(
+                "posthog.tracing._transport._get_session", return_value=mock_session()
+            ),
+            contexts.new_context(fresh=True, capture_exceptions=False),
+        ):
+            with (
+                pytest.raises(ValueError, match="handler failed")
+                if fail
+                else nullcontext()
+            ):
+                with tracer.start_as_current_span("request"):
+                    await app(http_scope(), noop_receive, send)
+            assert contexts.get_context_session_id() is None
+            assert contexts.get_context_distinct_id() is None
+            payload, _, _ = flush_and_capture(native)
+    finally:
+        native.shutdown()
+
+    assert responses[0]["status"] == (500 if fail else 200)
+    spans = {span.name: span for span in exporter.get_finished_spans()}
+    for name in ("request", "child"):
+        assert dict(spans[name].attributes) == {
+            "sessionId": "session-123",
+            "posthogDistinctId": "user-456",
+        }
+    [span] = spans_from(payload)
+    attributes = {item["key"]: item["value"] for item in span["attributes"]}
+    assert attributes["sessionId"] == {"stringValue": "session-123"}
+    assert attributes["posthogDistinctId"] == {"stringValue": "user-456"}
diff --git a/posthog/test/integrations/test_celery_otel_context.py b/posthog/test/integrations/test_celery_otel_context.py
new file mode 100644
index 000000000..678722cd4
--- /dev/null
+++ b/posthog/test/integrations/test_celery_otel_context.py
@@ -0,0 +1,238 @@
+from unittest.mock import Mock
+
+import pytest
+from celery import Celery
+from opentelemetry import trace
+from opentelemetry.instrumentation.celery import CeleryInstrumentor
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from posthog import contexts
+from posthog.integrations.celery import (
+    CONTEXT_DISTINCT_ID_HEADER,
+    CONTEXT_SESSION_ID_HEADER,
+    PosthogCeleryIntegration,
+)
+from posthog.integrations.otel import PostHogContextSpanProcessor
+
+
+@pytest.fixture
+def celery_tracing():
+    app = Celery("span-context", broker="memory://")
+    integration = PosthogCeleryIntegration(
+        client=Mock(disabled=False),
+        capture_exceptions=False,
+        capture_task_lifecycle_events=False,
+    )
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(PostHogContextSpanProcessor())
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    integration.instrument()
+    try:
+        yield app, provider.get_tracer(__name__), exporter, provider
+    finally:
+        integration.shutdown()
+        provider.shutdown()
+        app.close()
+
+
+@pytest.mark.parametrize("state", ["success", "failure", "retry"])
+@pytest.mark.parametrize("propagated", [True, False])
+def test_eager_task_enriches_existing_span_and_clears_context(
+    celery_tracing, state, propagated
+):
+    app, tracer, exporter, _ = celery_tracing
+    headers = (
+        {
+            CONTEXT_DISTINCT_ID_HEADER: "job-person",
+            CONTEXT_SESSION_ID_HEADER: "job-session",
+        }
+        if propagated
+        else {}
+    )
+    expected = (
+        {"posthogDistinctId": "job-person", "sessionId": "job-session"}
+        if propagated
+        else {}
+    )
+    attempts = []
+
+    @app.task(bind=True, name="span-context.task")
+    def task(self):
+        attempts.append(self.request.retries)
+        tracer.start_span("child").end()
+        assert contexts.get_context_distinct_id() == (
+            "job-person" if propagated else None
+        )
+        assert contexts.get_context_session_id() == (
+            "job-session" if propagated else None
+        )
+        if state == "failure":
+            raise ValueError("task failed")
+        if state == "retry" and self.request.retries == 0:
+            raise self.retry(exc=ValueError("try again"), countdown=0)
+        return "done"
+
+    task_id = "owned-task"
+    task_span = tracer.start_span("task", attributes={"celery.task_id": task_id})
+    with (
+        trace.use_span(task_span, end_on_exit=True),
+        contexts.new_context(fresh=True, capture_exceptions=False),
+    ):
+        contexts.identify_context("outer-person")
+        contexts.set_context_session("outer-session")
+        result = task.apply(task_id=task_id, headers=headers, throw=False)
+        assert result.state == ("FAILURE" if state == "failure" else "SUCCESS")
+        assert contexts.get_context_distinct_id() == "outer-person"
+        assert contexts.get_context_session_id() == "outer-session"
+
+    assert attempts == ([0, 1] if state == "retry" else [0])
+    tracer.start_span("after-task").end()
+    for span in exporter.get_finished_spans():
+        span_expected = {} if span.name == "after-task" else expected
+        if span.name == "task":
+            span_expected = {**span_expected, "celery.task_id": task_id}
+        assert dict(span.attributes) == span_expected
+
+
+def test_published_context_reaches_task_span_without_worker_context_bleed(
+    celery_tracing,
+):
+    app, tracer, exporter, _ = celery_tracing
+
+    @app.task(name="span-context.published")
+    def task():
+        tracer.start_span("child").end()
+        return contexts.get_context_distinct_id(), contexts.get_context_session_id()
+
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        contexts.identify_context("producer-person")
+        contexts.set_context_session("producer-session")
+        task.apply_async()
+
+    with app.connection_for_read() as connection:
+        with connection.SimpleQueue("celery") as queue:
+            message = queue.get(block=False)
+            worker_headers = message.headers["headers"]
+            message.ack()
+
+    with tracer.start_as_current_span(
+        "task", attributes={"celery.task_id": "published"}
+    ):
+        result = task.apply(task_id="published", headers=worker_headers)
+    assert result.get() == ("producer-person", "producer-session")
+
+    with tracer.start_as_current_span(
+        "unlinked-task", attributes={"celery.task_id": "unlinked"}
+    ):
+        assert task.apply(task_id="unlinked").get() == (None, None)
+    expected = {
+        "posthogDistinctId": "producer-person",
+        "sessionId": "producer-session",
+    }
+    spans = exporter.get_finished_spans()
+    assert [dict(span.attributes) for span in spans] == [
+        expected,
+        {**expected, "celery.task_id": "published"},
+        {},
+        {"celery.task_id": "unlinked"},
+    ]
+
+
+@pytest.mark.parametrize("state", ["success", "failure", "retry"])
+def test_official_eager_task_spans_do_not_stamp_the_caller(celery_tracing, state):
+    app, tracer, exporter, provider = celery_tracing
+    instrumentor = CeleryInstrumentor()
+    instrumentor.instrument(tracer_provider=provider)
+
+    @app.task(bind=True, name="span-context.official")
+    def task(self):
+        tracer.start_span(f"child-{self.request.id}").end()
+        if state == "failure":
+            raise ValueError("task failed")
+        if state == "retry" and self.request.retries == 0:
+            raise self.retry(exc=ValueError("try again"), countdown=0)
+        return "done"
+
+    try:
+        with tracer.start_as_current_span("caller") as caller:
+            for name in ("first", "second"):
+                result = task.apply(
+                    task_id=name,
+                    headers={
+                        CONTEXT_DISTINCT_ID_HEADER: f"{name}-person",
+                        CONTEXT_SESSION_ID_HEADER: f"{name}-session",
+                    },
+                    throw=False,
+                )
+                assert result.state == ("FAILURE" if state == "failure" else "SUCCESS")
+                assert dict(caller.attributes) == {}
+                assert contexts.get_context_distinct_id() is None
+                assert contexts.get_context_session_id() is None
+            tracer.start_span("after-tasks").end()
+    finally:
+        instrumentor.uninstrument()
+
+    task_spans = [
+        span
+        for span in exporter.get_finished_spans()
+        if span.kind == trace.SpanKind.CONSUMER
+    ]
+    assert len(task_spans) == (4 if state == "retry" else 2)
+    for span in exporter.get_finished_spans():
+        if span.name in ("caller", "after-tasks"):
+            assert dict(span.attributes) == {}
+        else:
+            name = (
+                span.name.removeprefix("child-")
+                if span.name.startswith("child-")
+                else span.attributes["messaging.message.id"]
+            )
+            assert span.attributes["posthogDistinctId"] == f"{name}-person"
+            assert span.attributes["sessionId"] == f"{name}-session"
+
+
+@pytest.mark.parametrize(
+    "attributes", [{}, {"celery.task_id": "other-task"}, {"celery.task_id": 42}]
+)
+def test_eager_task_does_not_enrich_an_unverified_span(celery_tracing, attributes):
+    app, tracer, exporter, _ = celery_tracing
+
+    @app.task(name="span-context.unverified")
+    def task():
+        tracer.start_span("child").end()
+
+    with tracer.start_as_current_span("task", attributes=attributes):
+        task.apply(
+            task_id="actual-task", headers={CONTEXT_SESSION_ID_HEADER: "job-session"}
+        )
+    child, parent = exporter.get_finished_spans()
+    assert dict(child.attributes) == {"sessionId": "job-session"}
+    assert dict(parent.attributes) == attributes
+
+
+@pytest.mark.parametrize("api_state", ["missing", "failing", "unreadable"])
+def test_task_context_survives_unavailable_current_span_api(
+    celery_tracing, monkeypatch, api_state
+):
+    app, _, _, _ = celery_tracing
+    if api_state == "missing":
+        monkeypatch.delattr(trace, "get_current_span")
+    elif api_state == "failing":
+        monkeypatch.setattr(
+            trace, "get_current_span", Mock(side_effect=RuntimeError("lookup failed"))
+        )
+    else:
+        monkeypatch.setattr(trace, "get_current_span", lambda: object())
+
+    @app.task(name="span-context.unavailable")
+    def task():
+        return contexts.get_context_session_id()
+
+    assert (
+        task.apply(headers={CONTEXT_SESSION_ID_HEADER: "job-session"}).get()
+        == "job-session"
+    )
+    assert contexts.get_context_session_id() is None
diff --git a/posthog/test/integrations/test_flask_spans.py b/posthog/test/integrations/test_flask_spans.py
new file mode 100644
index 000000000..59de68d35
--- /dev/null
+++ b/posthog/test/integrations/test_flask_spans.py
@@ -0,0 +1,177 @@
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import nullcontext
+from threading import Barrier
+from unittest.mock import patch
+
+import pytest
+from flask import Flask
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from posthog import contexts
+from posthog.integrations.flask import PosthogFlaskIntegration
+from posthog.integrations.otel import PostHogContextSpanProcessor
+from posthog.test.tracing.test_client_traces import (
+    flush_and_capture,
+    make_client,
+    mock_session,
+    spans_from,
+)
+
+
+@pytest.fixture
+def tracing(monkeypatch):
+    monkeypatch.setattr("posthog.project_api_key", "phc_key")
+    exporter = InMemorySpanExporter()
+    provider = TracerProvider()
+    provider.add_span_processor(PostHogContextSpanProcessor())
+    provider.add_span_processor(SimpleSpanProcessor(exporter))
+    yield provider.get_tracer(__name__), exporter
+    provider.shutdown()
+
+
+@pytest.fixture
+def native_client():
+    client = make_client(traces={})
+    with patch("posthog.tracing._transport._get_session", return_value=mock_session()):
+        yield client
+        client.shutdown()
+
+
+@pytest.mark.parametrize("fail", [False, True])
+def test_flask_enriches_existing_request_and_child_spans_and_cleans_up(
+    tracing, native_client, fail
+):
+    tracer, exporter = tracing
+    app = Flask(__name__)
+    app.config["TESTING"] = True
+    PosthogFlaskIntegration(app, capture_tracing_headers=True, capture_exceptions=False)
+
+    @app.get("/")
+    def view():
+        native_client.start_span("native").end()
+        tracer.start_span("child").end()
+        if fail:
+            raise ValueError("view failed")
+        return "response"
+
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        with pytest.raises(ValueError, match="view failed") if fail else nullcontext():
+            with tracer.start_as_current_span("request"):
+                response = app.test_client().get(
+                    "/",
+                    headers={
+                        "X-PostHog-Distinct-ID": "browser-person",
+                        "X-PostHog-Session-ID": "browser-session",
+                    },
+                )
+                assert response.status_code == 200
+        tracer.start_span("after-request").end()
+        assert contexts.get_context_distinct_id() is None
+        assert contexts.get_context_session_id() is None
+
+    spans = {span.name: dict(span.attributes) for span in exporter.get_finished_spans()}
+    expected = {
+        "posthogDistinctId": "browser-person",
+        "sessionId": "browser-session",
+    }
+    assert spans == {"request": expected, "child": expected, "after-request": {}}
+    payload, _, _ = flush_and_capture(native_client)
+    (native,) = spans_from(payload)
+    assert {
+        attribute["key"]: attribute["value"]["stringValue"]
+        for attribute in native["attributes"]
+    } == expected
+
+
+@pytest.mark.parametrize(
+    "trust,headers,attributes,expected",
+    [
+        (
+            False,
+            {"X-PostHog-Distinct-ID": "person", "X-PostHog-Session-ID": "session"},
+            {},
+            {},
+        ),
+        (True, {}, {}, {}),
+        (True, {"X-PostHog-Distinct-ID": "   ", "X-PostHog-Session-ID": "   "}, {}, {}),
+        (True, {"X-PostHog-Session-ID": "session"}, {}, {"sessionId": "session"}),
+        (
+            True,
+            {"X-PostHog-Distinct-ID": "person"},
+            {},
+            {"posthogDistinctId": "person"},
+        ),
+        (
+            True,
+            {"X-PostHog-Distinct-ID": "person", "X-PostHog-Session-ID": "session"},
+            {"posthogDistinctId": "own-person", "sessionId": "own-session"},
+            {"posthogDistinctId": "own-person", "sessionId": "own-session"},
+        ),
+        (
+            True,
+            {"X-PostHog-Distinct-ID": "person", "X-PostHog-Session-ID": "session"},
+            {"user.id": "authenticated"},
+            {"user.id": "authenticated", "sessionId": "session"},
+        ),
+    ],
+)
+def test_flask_request_span_respects_header_policy_and_explicit_identity(
+    tracing, trust, headers, attributes, expected
+):
+    tracer, exporter = tracing
+    app = Flask(__name__)
+    PosthogFlaskIntegration(
+        app, capture_tracing_headers=trust, capture_exceptions=False
+    )
+    app.add_url_rule("/", view_func=lambda: "response")
+
+    with contexts.new_context(fresh=True, capture_exceptions=False):
+        with tracer.start_as_current_span("request", attributes=attributes):
+            assert app.test_client().get("/", headers=headers).status_code == 200
+
+    assert dict(exporter.get_finished_spans()[0].attributes) == expected
+
+
+def test_flask_concurrent_requests_keep_separate_span_context(tracing):
+    tracer, exporter = tracing
+    app = Flask(__name__)
+    both_started = Barrier(2)
+    PosthogFlaskIntegration(app, capture_tracing_headers=True, capture_exceptions=False)
+
+    @app.get("/<identity>")
+    def view(identity):
+        both_started.wait(timeout=5)
+        tracer.start_span(identity + "-child").end()
+        return "response"
+
+    def run_request(identity):
+        with contexts.new_context(fresh=True, capture_exceptions=False):
+            with tracer.start_as_current_span(identity):
+                assert (
+                    app.test_client()
+                    .get(
+                        "/" + identity,
+                        headers={
+                            "X-PostHog-Distinct-ID": identity,
+                            "X-PostHog-Session-ID": identity + "-session",
+                        },
+                    )
+                    .status_code
+                    == 200
+                )
+            tracer.start_span(identity + "-after").end()
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        list(executor.map(run_request, ("first", "second")))
+
+    spans = {span.name: dict(span.attributes) for span in exporter.get_finished_spans()}
+    for identity in ("first", "second"):
+        expected = {
+            "posthogDistinctId": identity,
+            "sessionId": identity + "-session",
+        }
+        assert spans[identity] == expected
+        assert spans[identity + "-child"] == expected
+        assert spans[identity + "-after"] == {}
diff --git a/pyproject.toml b/pyproject.toml
index 3997eb889..753d86021 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -70,6 +70,9 @@ dev = [
 test = [
     "freezegun==1.5.1",
     "flask>=2.2",
+    "celery>=5.3,<6",
+    "opentelemetry-instrumentation-celery>=0.41b0",
+    "fastapi>=0.115,<1",
     "python-dateutil>=2.9.0.post0",
     "tzdata",
     "coverage",
diff --git a/references/middleware_configuration.md b/references/middleware_configuration.md
index 70cc236e3..472d2dc94 100644
--- a/references/middleware_configuration.md
+++ b/references/middleware_configuration.md
@@ -122,6 +122,35 @@ request handlers use the same bridge. Tracing headers are captured by default.
 Set `POSTHOG_MW_CAPTURE_TRACING_HEADERS = False` to disable extraction. These
 headers remain untrusted analytics context.
 
+Flask's `PosthogFlaskIntegration` adds IDs to the active OpenTelemetry SDK
+request span after its request hook sets the context. Keep OpenTelemetry's WSGI
+middleware outside the Flask app so that its request span is active before
+Flask runs `before_request` hooks. Browser session and person headers are captured
+by default. Set `capture_tracing_headers=False` to disable extraction. Register the shared processor above for
+child spans; the request hook alone does not enrich later OpenTelemetry spans.
+The application must set authenticated identity on the request span before the
+PostHog hook if that identity must take precedence over a browser header.
+Requests excluded by `request_filter` receive no enrichment. Flask request
+context closes in `teardown_request`, including when the view raises an error.
+
+ASGI's `PosthogASGIMiddleware` also adds IDs after it reads the headers. This
+covers an active recording request span started by outer tracing middleware.
+FastAPI applications use the same ASGI middleware:
+
+```python
+from posthog.integrations.asgi import PosthogASGIMiddleware
+
+app.add_middleware(PosthogASGIMiddleware)
+```
+
+Keep OpenTelemetry request tracing outside this middleware and register
+`PostHogContextSpanProcessor` for child spans. Both async handlers and FastAPI's
+sync handlers run within the request context. HTTP and WebSocket scopes are
+supported; WebSocket tracing requires the application to supply a recording span.
+Lifespan scopes and requests rejected by `request_filter` pass through without
+span enrichment. The middleware does not create request spans. Spans started by
+outer error-response handlers after the PostHog scope exits omit request IDs.
+
 For a custom request integration, call `enrich_current_span()` from
 `posthog.integrations.otel` once after setting the request IDs. This call handles
 an already active recording SDK span. The processor handles spans started later
@@ -135,3 +164,34 @@ A background task can set its own IDs in a new `new_context()` scope.
 Only IDs from active scopes are used. Set `fresh=True` to prevent inheritance
 from any parent scope.
 The AI OpenTelemetry processor is a separate integration with different attributes.
+
+## Celery task spans
+
+`PosthogCeleryIntegration` carries context through its existing task message
+headers when `propagate_context=True` (the default). Instrument the producer and
+each worker process. A worker starts a fresh PostHog context before each task and
+restores the prior context after success, failure, or retry. A task without
+PostHog headers does not inherit identity or session IDs from an enclosing scope.
+
+Add `PostHogContextSpanProcessor` to the application's existing provider for
+child spans. The Celery integration also enriches an active task span after it
+reads the message headers, but only when its public `celery.task_id` attribute
+exactly matches the current task ID. Other active spans remain unchanged.
+It does not create task spans. To create task spans,
+install and configure `opentelemetry-instrumentation-celery` separately.
+
+Call `PosthogCeleryIntegration.instrument()` before
+`CeleryInstrumentor().instrument(tracer_provider=provider)`. This order ensures
+that PostHog restores the job context before OpenTelemetry starts the task span.
+This also matters for eager and nested tasks: with the reverse order, the span
+processor can read the enclosing context before the task context is available.
+Existing span attributes are preserved, so the later task hook cannot replace
+those values. Official Celery instrumentation does not expose a matching
+`celery.task_id` at this hook. The later task hook therefore cannot repair task
+spans created in the reverse order.
+
+Celery's eager execution does not emit task publish signals. To carry context
+into an eager task, pass the task's PostHog headers explicitly with
+`task.apply(headers=...)` or `task.apply_async(headers=...)`. Do not use these
+analytics headers for authentication or authorization. Task context propagation
+does not grant a background task access to an ended request scope.
diff --git a/uv.lock b/uv.lock
index 48f25f3c0..7292cfbbc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -257,6 +257,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
 ]
 
+[[package]]
+name = "amqp"
+version = "5.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "vine" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/41/63526ffa542b7dbeb671ab2252fb38e26cd2dbc68c0775cdc5ba11af78a7/amqp-5.4.1.tar.gz", hash = "sha256:79a9c0ab70e71745667f127ff80666894a734c26236b6f33149c964b096f0b20", size = 132240, upload-time = "2026-10-05T14:03:23.415Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/8e/25f762f8cf0da76c7b1a66a9cadc291168537598c533954b0e2c9de3a0a3/amqp-5.4.1-py3-none-any.whl", hash = "sha256:ac2b816a14a380ed10c5ebbf85a334fd68111fa476496867a5ccd2fd09926d5e", size = 51858, upload-time = "2026-10-05T14:03:18.61Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },
+]
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -397,6 +418,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/71/cc/18245721fa7747065ab478316c7fea7c74777d07f37ae60db2e84f8172e8/beartype-0.22.9-py3-none-any.whl", hash = "sha256:d16c9bbc61ea14637596c5f6fbff2ee99cbe3573e46a716401734ef50c3060c2", size = 1333658, upload-time = "2025-12-13T06:50:28.266Z" },
 ]
 
+[[package]]
+name = "billiard"
+version = "4.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/0d/8921e960be19fa226358bf933509f57ec679d9b35a1e7ea43460af4b7fef/billiard-4.3.1.tar.gz", hash = "sha256:c88559b306ee5dc93f8d5f843d07da15d795d67af26720d14ee9d09f09eb0b22", size = 166478, upload-time = "2026-10-05T06:38:30.496Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/b1/360936699597063a2d9863aa94ccc3a6951e906ced032a9a1d8e562fc56b/billiard-4.3.1-py3-none-any.whl", hash = "sha256:2c7075283191d9c0add66cf8fca8e06ba599e75fe7319b67186759f8877dfdaf", size = 90178, upload-time = "2026-10-05T06:38:28.373Z" },
+]
+
 [[package]]
 name = "blinker"
 version = "1.9.0"
@@ -444,6 +474,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/86/93/1f76c8d1bafe3b0614e06b2195784a3765bbf7b0a067661af9e2dd47fc33/caio-0.9.25-py3-none-any.whl", hash = "sha256:06c0bb02d6b929119b1cfbe1ca403c768b2013a369e2db46bfa2a5761cf82e40", size = 19087, upload-time = "2025-12-26T15:22:00.221Z" },
 ]
 
+[[package]]
+name = "celery"
+version = "5.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "billiard" },
+    { name = "click" },
+    { name = "click-didyoumean" },
+    { name = "click-plugins" },
+    { name = "click-repl" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "kombu" },
+    { name = "python-dateutil" },
+    { name = "tzlocal" },
+    { name = "vine" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e8/b4/a1233943ab5c8ea05fb877a88a0a0622bf47444b99e4991a8045ac37ea1d/celery-5.6.3.tar.gz", hash = "sha256:177006bd2054b882e9f01be59abd8529e88879ef50d7918a7050c5a9f4e12912", size = 1742243, upload-time = "2026-03-26T12:14:51.76Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/c9/6eccdda96e098f7ae843162db2d3c149c6931a24fda69fe4ab84d0027eb5/celery-5.6.3-py3-none-any.whl", hash = "sha256:0808f42f80909c4d5833202360ffafb2a4f83f4d8e23e1285d926610e9a7afa6", size = 451235, upload-time = "2026-03-26T12:14:49.491Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.6.15"
@@ -664,6 +715,44 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
+[[package]]
+name = "click-didyoumean"
+version = "0.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/30/ce/217289b77c590ea1e7c24242d9ddd6e249e52c795ff10fac2c50062c48cb/click_didyoumean-0.3.1.tar.gz", hash = "sha256:4f82fdff0dbe64ef8ab2279bd6aa3f6a99c3b28c05aa09cbfc07c9d7fbb5a463", size = 3089, upload-time = "2024-03-24T08:22:07.499Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/5b/974430b5ffdb7a4f1941d13d83c64a0395114503cc357c6b9ae4ce5047ed/click_didyoumean-0.3.1-py3-none-any.whl", hash = "sha256:5c4bb6007cfea5f2fd6583a2fb6701a22a41eb98957e63d0fac41c10e7c3117c", size = 3631, upload-time = "2024-03-24T08:22:06.356Z" },
+]
+
+[[package]]
+name = "click-plugins"
+version = "1.1.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/a4/34847b59150da33690a36da3681d6bbc2ec14ee9a846bc30a6746e5984e4/click_plugins-1.1.1.2.tar.gz", hash = "sha256:d7af3984a99d243c131aa1a828331e7630f4a88a9741fd05c927b204bcf92261", size = 8343, upload-time = "2025-06-25T00:47:37.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/9a/2abecb28ae875e39c8cad711eb1186d8d14eab564705325e77e4e6ab9ae5/click_plugins-1.1.1.2-py2.py3-none-any.whl", hash = "sha256:008d65743833ffc1f5417bf0e78e8d2c23aab04d9745ba817bd3e71b0feb6aa6", size = 11051, upload-time = "2025-06-25T00:47:36.731Z" },
+]
+
+[[package]]
+name = "click-repl"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "prompt-toolkit" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/50/bea78619ff1fc0fbd61882f64a1302a8abb2ea0b3db92907042d0e362df2/click_repl-0.4.1.tar.gz", hash = "sha256:c32a1cf6f95e5bd6e92076f81ce24eafd33f2f0ffb0135887e335b8e446d1c0b", size = 16403, upload-time = "2026-10-05T06:01:57.607Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/f6/12dc0f2e0159c2b416818b7fedcda15b520043773364a81d7389809a5af5/click_repl-0.4.1-py3-none-any.whl", hash = "sha256:5cb10881d4c5ebaa8695eceb69911af3062ee78342812b713564b17aad333eb5", size = 14988, upload-time = "2026-10-05T06:01:55.611Z" },
+]
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -937,6 +1026,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
 ]
 
+[[package]]
+name = "fastapi"
+version = "0.141.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" },
+]
+
 [[package]]
 name = "fastmcp"
 version = "3.2.0"
@@ -1681,6 +1786,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d3/32/da7f44bcb1105d3e88a0b74ebdca50c59121d2ddf71c9e34ba47df7f3a56/keyring-25.6.0-py3-none-any.whl", hash = "sha256:552a3f7af126ece7ed5c89753650eec89c7eaae8617d0aa4d9ad2b75111266bd", size = 39085, upload-time = "2024-12-25T15:26:44.377Z" },
 ]
 
+[[package]]
+name = "kombu"
+version = "5.6.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "amqp" },
+    { name = "packaging" },
+    { name = "tzdata" },
+    { name = "vine" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/a5/607e533ed6c83ae1a696969b8e1c137dfebd5759a2e9682e26ff1b97740b/kombu-5.6.2.tar.gz", hash = "sha256:8060497058066c6f5aed7c26d7cd0d3b574990b09de842a8c5aaed0b92cc5a55", size = 472594, upload-time = "2025-12-29T20:30:07.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/0f/834427d8c03ff1d7e867d3db3d176470c64871753252b21b4f4897d1fa45/kombu-5.6.2-py3-none-any.whl", hash = "sha256:efcfc559da324d41d61ca311b0c64965ea35b4c55cc04ee36e55386145dace93", size = 214219, upload-time = "2025-12-29T20:30:05.74Z" },
+]
+
 [[package]]
 name = "langchain"
 version = "1.4.4"
@@ -2618,6 +2738,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
 ]
 
+[[package]]
+name = "opentelemetry-instrumentation"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "packaging" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-celery"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/43/e79108a804d16b1dc8ff28edd0e94ac393cf6359a5adcd7cdd2ec4be85f4/opentelemetry_instrumentation_celery-0.61b0.tar.gz", hash = "sha256:0e352a567dc89ed8bc083fc635035ce3c5b96bbbd92831ffd676e93b87f8e94f", size = 14780, upload-time = "2026-03-04T14:20:27.776Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/ed/c05f3c84b455654eb6c047474ffde61ed92efc24030f64213c98bca9d44b/opentelemetry_instrumentation_celery-0.61b0-py3-none-any.whl", hash = "sha256:01235733ff0cdf571cb03b270645abb14b9c8d830313dc5842097ec90146320b", size = 13856, upload-time = "2026-03-04T14:19:20.98Z" },
+]
+
 [[package]]
 name = "opentelemetry-proto"
 version = "1.40.0"
@@ -2912,10 +3061,12 @@ otel = [
 ]
 test = [
     { name = "anthropic" },
+    { name = "celery" },
     { name = "claude-agent-sdk" },
     { name = "coverage" },
     { name = "django" },
     { name = "djangorestframework" },
+    { name = "fastapi" },
     { name = "fastmcp" },
     { name = "flask" },
     { name = "freezegun" },
@@ -2932,6 +3083,7 @@ test = [
     { name = "mcp" },
     { name = "openai-agents" },
     { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-instrumentation-celery" },
     { name = "opentelemetry-sdk" },
     { name = "parameterized" },
     { name = "pydantic" },
@@ -2957,12 +3109,14 @@ dev = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -2986,6 +3140,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -3034,6 +3189,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/74/a88bf1b1efeae488a0c0b7bdf71429c313722d1fc0f377537fbe554e6180/pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd", size = 220707, upload-time = "2025-03-18T21:35:19.343Z" },
 ]
 
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.53"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ea/39b988c938f75cb75d7045b5c69f8bfed47ee2152c8837fb403de29d6fb8/prompt_toolkit-3.0.53.tar.gz", hash = "sha256:9ec8a0ad96d5c56148b3f914aa79c1564c3fde5d2e6b876e7bc327e353cf8fa6", size = 435492, upload-time = "2026-07-26T20:56:14.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/6f/84908cad2d6aa5144abcf7b42709fe4fdb459bc640ec7ac5786e7693dabc/prompt_toolkit-3.0.53-py3-none-any.whl", hash = "sha256:01c0891d7f9237d5e339f7d3e42cdae80b7534abb1c7c0e3352efba6231492f2", size = 392288, upload-time = "2026-07-26T20:56:12.512Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.3.2"
@@ -4206,6 +4373,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
 ]
 
+[[package]]
+name = "tzlocal"
+version = "5.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tzdata", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/5b/879b2f932adfa7a053c360d50bc896c977fa6426109185f7c12ebdd0cb9d/tzlocal-5.4.4.tar.gz", hash = "sha256:8dbb8660838688a7b6ba4fed31d18dedf842afb4d47ca050d6d891c2c15f3be4", size = 31170, upload-time = "2026-06-29T08:03:40.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/a4/017a7a6cbe387d961a688ec31364ae60a5c4e22c96ae9921b79a947c855d/tzlocal-5.4.4-py3-none-any.whl", hash = "sha256:aae09f0126a8a86fa736be266eb4a471380d26a0de3bc14844e7821fee3e2a15", size = 18115, upload-time = "2026-06-29T08:03:38.666Z" },
+]
+
 [[package]]
 name = "uncalled-for"
 version = "0.3.2"
@@ -4267,6 +4446,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
 ]
 
+[[package]]
+name = "vine"
+version = "5.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/e4/d07b5f29d283596b9727dd5275ccbceb63c44a1a82aa9e4bfd20426762ac/vine-5.1.0.tar.gz", hash = "sha256:8b62e981d35c41049211cf62a0a1242d8c1ee9bd15bb196ce38aefd6799e61e0", size = 48980, upload-time = "2023-11-05T08:46:53.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/ff/7c0c86c43b3cbb927e0ccc0255cb4057ceba4799cd44ae95174ce8e8b5b2/vine-5.1.0-py3-none-any.whl", hash = "sha256:40fdf3c48b2cfe1c38a49e9ae2da6fda88e4794c810050a728bd7413811fb1dc", size = 9636, upload-time = "2023-11-05T08:46:51.205Z" },
+]
+
 [[package]]
 name = "virtualenv"
 version = "21.7.13"
@@ -4400,6 +4588,42 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/f9/45d021e4a5cc7b9dd567f7cbb06d3b75f751a690063fb6cc7ec60f4e46b7/watchfiles-1.2.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a88fc94e647bc4eec523f1caa540258eb71d14278b9daf72fa1e2658a98df0f0", size = 457771, upload-time = "2026-05-18T04:30:56.331Z" },
 ]
 
+[[package]]
+name = "wcwidth"
+version = "0.9.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/b4/7830542634bb2d3e62aa3b586a72d5b3b6c91c3168929e7000ef3fed041d/wcwidth-0.9.2.tar.gz", hash = "sha256:ae0ef90b90f6af38b54f1fe6d58662ec33b3cb4b8391958a62416d654231727b", size = 955039, upload-time = "2026-10-05T00:24:05.521Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/1e/4532a81fb9dfbf4114a816775e0a36c3a64ee1d1f4bba2094e2da50be5dc/wcwidth-0.9.2-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:7ef5a940bd5e30bac6e721f1a48fce0cd7bb3ece19e9c5d139e72c76c35cfd07", size = 605343, upload-time = "2026-10-05T00:23:22.649Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/07/cb6940e81134b7ed25fa312ee9ab536a63db0793b149f88a90e603ceace9/wcwidth-0.9.2-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:ae0800c5339423cc53d33a266ad264b42ba8aaa16d4464f6e6b1bee607f50b17", size = 609960, upload-time = "2026-10-05T00:23:27.049Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/80/15ad05d40bfa99155639fb9e13b3d77083aa0fab893c816db2543d29005c/wcwidth-0.9.2-cp310-abi3-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:9e542f1f8475b78452a295495d7a5bc3ead565112e9446a64dc93462a41c2a79", size = 762566, upload-time = "2026-10-05T00:23:38.322Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/f0/b8ef7758003d66b60f093695831a86dcc726aac01ee6446ffcbda27b61e3/wcwidth-0.9.2-cp310-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:674b518af28d38ee645ff97b74f5760abee5fad4bac74413bfc4b881ef2ce724", size = 771632, upload-time = "2026-10-05T00:23:32.448Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6c/f940133c71427c208575910e981942bd78c98b1f7cd0d1425ca4b7457c04/wcwidth-0.9.2-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:751bef0ab404b6a1dc028b56b4b85d46486be1c55833f80da533e42dc691f389", size = 769763, upload-time = "2026-10-05T00:23:40.175Z" },
+    { url = "https://files.pythonhosted.org/packages/92/8f/285f862826f721964ec7c42f81dc53d23afbd723a0f4cd989651f8218e25/wcwidth-0.9.2-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c3d80f39ba4653a595edae9aa46a509d14883790a8fc23c5db221ceb207f64b7", size = 782134, upload-time = "2026-10-05T00:23:33.926Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/2d/64aa54882a5d556d3654c1f926d9118b797461033e23a158409941a37c8f/wcwidth-0.9.2-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:0a47e03d8293590ecce66c45dc20ff7b4b885e3c78093722239585eca0d77ab2", size = 782851, upload-time = "2026-10-05T00:23:41.974Z" },
+    { url = "https://files.pythonhosted.org/packages/59/39/52389f6de7fe2e9c14ceb8253dd99034bd86e1c87847ea3c100a97dded9a/wcwidth-0.9.2-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:67d901a4ad99249eb775b4ee4769ca97fa405d35a75f46e83166910a47003f04", size = 784621, upload-time = "2026-10-05T00:23:43.449Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/20225500a076ace27bbcc8a6fd7c55125133c57a618816c7b7b8b73070b1/wcwidth-0.9.2-cp310-abi3-win32.whl", hash = "sha256:ee1fd0db9d9fd711a70f3e7765e0e04c05d26982fa05361456163062549d7da4", size = 593123, upload-time = "2026-10-05T00:23:55.953Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/d6/b0690f55ea0483530a18bac917fbadbf54f35122510446fc370f5f1c2453/wcwidth-0.9.2-cp310-abi3-win_amd64.whl", hash = "sha256:2a9746de704242bd4fdaabb31dd46b82f694a56a8d21081ad89b679a89da9fec", size = 597827, upload-time = "2026-10-05T00:23:57.489Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/11/6ecf4e9e268ab1a4ec617ffcccc2ee4a71301625f5490912dbaba462fa9c/wcwidth-0.9.2-cp310-abi3-win_arm64.whl", hash = "sha256:b9c6ab615e03723b7f8760ea2f27758d656e7e13b51515c9dca5c3e8b04612fa", size = 598415, upload-time = "2026-10-05T00:23:51.517Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/41/549eef1ab767032bdbdc1f0ab655d404b082b1e9a1dab1361dbba90f64ed/wcwidth-0.9.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eda88ffdc97c0fbf193d407114f2c7a54b379f67f6e52a7531ee3b9fe749eca7", size = 606555, upload-time = "2026-10-05T00:23:24.188Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/64/a875ed7ea71cacadc0ae11b5fd3fac3486efd58bb25e67a7344248dceadd/wcwidth-0.9.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1bf361c8705576760623b4724ae564666d73b016f9a778bcfd1c7345378ef4ec", size = 610829, upload-time = "2026-10-05T00:23:28.563Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/98/513095e484fe79b6f2613d6a72f855f5d56b65e15c215c2a6746fbc638f5/wcwidth-0.9.2-cp314-cp314t-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:97b878d1e158da5ed9ac5aac53fa3a55e282103af6a09ec353865613d1a31a76", size = 775819, upload-time = "2026-10-05T00:23:45.116Z" },
+    { url = "https://files.pythonhosted.org/packages/22/fc/c02f3eec57224731e78f84b68e272250f784b6205acc7e0dcef6a7c23a0e/wcwidth-0.9.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:59dab4049cbd982b478bca098528df2c79a9160636a3a163ffebffcbd7d1b892", size = 786915, upload-time = "2026-10-05T00:23:35.323Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/b0529a79bac3fe8d94f32b4237a13dbc3f955508753f6a6f06c73d679dc2/wcwidth-0.9.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb08ceb501d6aaf94066c3ee122dd825b152df40ff0bd0df4dc27126233b948e", size = 784186, upload-time = "2026-10-05T00:23:46.366Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/bd/6357c84ca9a734bfc735b7c48dbe21336b3777fab8a4101d14976dfe49a7/wcwidth-0.9.2-cp314-cp314t-win32.whl", hash = "sha256:8b4e381590b9b7390e07e22b2c0c1bb96ce50e1d2243c866d9387600362d51ed", size = 600791, upload-time = "2026-10-05T00:23:59.398Z" },
+    { url = "https://files.pythonhosted.org/packages/98/de/037591ca18d897cc2179559dde72e6efc6ce0c90e9cd1e6bca4e87c38b4b/wcwidth-0.9.2-cp314-cp314t-win_amd64.whl", hash = "sha256:f2f7b3bba5a5d5f31fc350fd36ce5b84b693c83b7eb95ee630b720da5a5ce06f", size = 605463, upload-time = "2026-10-05T00:24:01.049Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/07/c9d96e106d938d26f7ab639bc80b8199359a1645ba6e3498413313ab6f38/wcwidth-0.9.2-cp314-cp314t-win_arm64.whl", hash = "sha256:734aa9405b321d1042301aa19c943c4731ee9e3460e4f8feea3299c064c97a14", size = 605936, upload-time = "2026-10-05T00:23:52.765Z" },
+    { url = "https://files.pythonhosted.org/packages/82/8a/a28d61d910005ac93dfe48be3a0ebaa49352d88cebd25323e69e6ff2f4a8/wcwidth-0.9.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:42dbcb76ce8af39e2c9db410ac3f9bdf4e47eb41d6f44525952f172d3d98f724", size = 606575, upload-time = "2026-10-05T00:23:25.663Z" },
+    { url = "https://files.pythonhosted.org/packages/01/c2/a3c66bd32766c8f4d6dc47d572532ba014fe5be30489f2576aff7cada363/wcwidth-0.9.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:138e1f8898e431b2f2d7881f8ca8d75591c1d3c21aa53f54e989bd6b39811da2", size = 611045, upload-time = "2026-10-05T00:23:30.421Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/8a/d39964f8f8c019d7d439b9b501d3e7bb42fee69f00354040ba0b27b5824c/wcwidth-0.9.2-cp315-cp315t-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5175609bf8cc7398a5f48aa35207bd64ebf9f45e4c70df65f7fdc7a988041a3c", size = 778143, upload-time = "2026-10-05T00:23:47.7Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/53/525da13e8f9ff7b5b4e74ec6f8d68bdee63905796972e086c6b1b96670d2/wcwidth-0.9.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e5f669ae8c3d969c72032f9cdee019674b666e522d45e1e2099a2e9dda4a341d", size = 786630, upload-time = "2026-10-05T00:23:36.967Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/9f/d6a0c6df354b9d93466548a65cbf4ffcb48c719bbd307504cf3e76740837/wcwidth-0.9.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:196b47cf32f9df27ccda6dc513237f3c2429c4c659db428d60a5bc443d10f270", size = 784839, upload-time = "2026-10-05T00:23:49.88Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/d7/3021feed1ed7926021ec134943ad3b24a2f7ea742cc9976461171482ed77/wcwidth-0.9.2-cp315-cp315t-win32.whl", hash = "sha256:0cd4f7f2e53905dcb110d213a4c8529b6733fa3d232d8c717f946cc69a10349b", size = 600845, upload-time = "2026-10-05T00:24:02.497Z" },
+    { url = "https://files.pythonhosted.org/packages/63/80/6a03356d8ee38261e3a78cf89ee03d8e7f12c572d969237be00869e2dc73/wcwidth-0.9.2-cp315-cp315t-win_amd64.whl", hash = "sha256:33df042f96c61ed3cd5fb3742fba427553a635bc578799857a48aa79f774a0b9", size = 605441, upload-time = "2026-10-05T00:24:04.052Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/48/1a308a86a833fd12ff7a08d0d2491ff4a72c8a92d12f5ead8317630f771e/wcwidth-0.9.2-cp315-cp315t-win_arm64.whl", hash = "sha256:48719a9bc76c2f84238693fe5013571fa5beffa3621cf228f1f3a9e30dae84b8", size = 605885, upload-time = "2026-10-05T00:23:54.274Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/b4/0bfa065af506540d9d558e3e5548cff00bc1f9b24e6e2a8512498e8628de/wcwidth-0.9.2-py3-none-any.whl", hash = "sha256:89ca642c5bf0101157a09366be69fad0379db1f700ae39a920e103234573670e", size = 301667, upload-time = "2026-10-05T00:23:21.097Z" },
+]
+
 [[package]]
 name = "websockets"
 version = "15.0.1"
@@ -4480,6 +4704,75 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0b/2c/87f3254fd8ffd29e4c02732eee68a83a1d3c346ae39bc6822dcbcb697f2b/wheel-0.45.1-py3-none-any.whl", hash = "sha256:708e7481cc80179af0e556bbf0cc00b8444c7321e2700b8d8580231d13017248", size = 72494, upload-time = "2024-11-23T00:18:21.207Z" },
 ]
 
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/23/bb82321b86411eb51e5a5db3fb8f8032fd30bd7c2d74bfe936136b2fa1d6/wrapt-1.17.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88bbae4d40d5a46142e70d58bf664a89b6b4befaea7b2ecc14e03cedb8e06c04", size = 53482, upload-time = "2025-08-12T05:51:44.467Z" },
+    { url = "https://files.pythonhosted.org/packages/45/69/f3c47642b79485a30a59c63f6d739ed779fb4cc8323205d047d741d55220/wrapt-1.17.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b13af258d6a9ad602d57d889f83b9d5543acd471eee12eb51f5b01f8eb1bc2", size = 38676, upload-time = "2025-08-12T05:51:32.636Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/71/e7e7f5670c1eafd9e990438e69d8fb46fa91a50785332e06b560c869454f/wrapt-1.17.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd341868a4b6714a5962c1af0bd44f7c404ef78720c7de4892901e540417111c", size = 38957, upload-time = "2025-08-12T05:51:54.655Z" },
+    { url = "https://files.pythonhosted.org/packages/de/17/9f8f86755c191d6779d7ddead1a53c7a8aa18bccb7cea8e7e72dfa6a8a09/wrapt-1.17.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f9b2601381be482f70e5d1051a5965c25fb3625455a2bf520b5a077b22afb775", size = 81975, upload-time = "2025-08-12T05:52:30.109Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/15/dd576273491f9f43dd09fce517f6c2ce6eb4fe21681726068db0d0467096/wrapt-1.17.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343e44b2a8e60e06a7e0d29c1671a0d9951f59174f3709962b5143f60a2a98bd", size = 83149, upload-time = "2025-08-12T05:52:09.316Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/c4/5eb4ce0d4814521fee7aa806264bf7a114e748ad05110441cd5b8a5c744b/wrapt-1.17.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:33486899acd2d7d3066156b03465b949da3fd41a5da6e394ec49d271baefcf05", size = 82209, upload-time = "2025-08-12T05:52:10.331Z" },
+    { url = "https://files.pythonhosted.org/packages/31/4b/819e9e0eb5c8dc86f60dfc42aa4e2c0d6c3db8732bce93cc752e604bb5f5/wrapt-1.17.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e6f40a8aa5a92f150bdb3e1c44b7e98fb7113955b2e5394122fa5532fec4b418", size = 81551, upload-time = "2025-08-12T05:52:31.137Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/83/ed6baf89ba3a56694700139698cf703aac9f0f9eb03dab92f57551bd5385/wrapt-1.17.3-cp310-cp310-win32.whl", hash = "sha256:a36692b8491d30a8c75f1dfee65bef119d6f39ea84ee04d9f9311f83c5ad9390", size = 36464, upload-time = "2025-08-12T05:53:01.204Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/90/ee61d36862340ad7e9d15a02529df6b948676b9a5829fd5e16640156627d/wrapt-1.17.3-cp310-cp310-win_amd64.whl", hash = "sha256:afd964fd43b10c12213574db492cb8f73b2f0826c8df07a68288f8f19af2ebe6", size = 38748, upload-time = "2025-08-12T05:53:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/c3/cefe0bd330d389c9983ced15d326f45373f4073c9f4a8c2f99b50bfea329/wrapt-1.17.3-cp310-cp310-win_arm64.whl", hash = "sha256:af338aa93554be859173c39c85243970dc6a289fa907402289eeae7543e1ae18", size = 36810, upload-time = "2025-08-12T05:52:51.906Z" },
+    { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" },
+    { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" },
+    { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" },
+    { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" },
+    { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" },
+    { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" },
+    { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" },
+    { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" },
+    { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" },
+    { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" },
+    { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" },
+    { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" },
+    { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" },
+    { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
+]
+
 [[package]]
 name = "xxhash"
 version = "3.5.0"

From 908c77bc34e73aab009d04248131ccdbfe5ade5a Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:21:36 +0000
Subject: [PATCH 067/245] chore: Release v7.75.0 [skip ci]

---
 .sampo/changesets/asgi-otel-span-context.md   |  5 -----
 .sampo/changesets/celery-otel-span-context.md |  5 -----
 .sampo/changesets/django-otel-span-context.md |  5 -----
 .sampo/changesets/flask-otel-span-context.md  |  5 -----
 openfeature-provider/CHANGELOG.md             |  6 ++++++
 openfeature-provider/pyproject.toml           |  2 +-
 posthog/CHANGELOG.md                          | 12 ++++++++++++
 posthog/version.py                            |  2 +-
 pyproject.toml                                |  2 +-
 uv.lock                                       |  4 ++--
 10 files changed, 23 insertions(+), 25 deletions(-)
 delete mode 100644 .sampo/changesets/asgi-otel-span-context.md
 delete mode 100644 .sampo/changesets/celery-otel-span-context.md
 delete mode 100644 .sampo/changesets/django-otel-span-context.md
 delete mode 100644 .sampo/changesets/flask-otel-span-context.md

diff --git a/.sampo/changesets/asgi-otel-span-context.md b/.sampo/changesets/asgi-otel-span-context.md
deleted file mode 100644
index a3d821ea2..000000000
--- a/.sampo/changesets/asgi-otel-span-context.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Add active PostHog request IDs to existing OpenTelemetry spans in ASGI middleware.
diff --git a/.sampo/changesets/celery-otel-span-context.md b/.sampo/changesets/celery-otel-span-context.md
deleted file mode 100644
index 0cb6c9285..000000000
--- a/.sampo/changesets/celery-otel-span-context.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Add propagated task context to active Celery OpenTelemetry spans.
diff --git a/.sampo/changesets/django-otel-span-context.md b/.sampo/changesets/django-otel-span-context.md
deleted file mode 100644
index 90a517cd3..000000000
--- a/.sampo/changesets/django-otel-span-context.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add an optional OpenTelemetry span processor for PostHog request IDs and enrich active Django request spans after request context is available.
diff --git a/.sampo/changesets/flask-otel-span-context.md b/.sampo/changesets/flask-otel-span-context.md
deleted file mode 100644
index fc475163a..000000000
--- a/.sampo/changesets/flask-otel-span-context.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Add available PostHog request IDs to active Flask OpenTelemetry request spans.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index eb45ccb44..f33e39997 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.114 — 2026-10-21
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.0
+
 ## 0.1.113 — 2026-10-21
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 923b64784..6a9dd6b7e 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.113"
+version = "0.1.114"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 9b6467603..5421d4df4 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,17 @@
 # posthog
 
+## 7.75.0 — 2026-10-21
+
+### Minor changes
+
+- [5f01fe9](https://github.com/posthog/posthog-python/commit/5f01fe93b893944f9b04c9e0f0536df46810143f) Add an optional OpenTelemetry span processor for PostHog request IDs and enrich active Django request spans after request context is available. — Thanks @pauldambra!
+
+### Patch changes
+
+- [5ddb446](https://github.com/posthog/posthog-python/commit/5ddb4464a634a1dddf9b585cb9cf804c671a2edf) Add available PostHog request IDs to active Flask OpenTelemetry request spans. — Thanks @pauldambra!
+- [5ddb446](https://github.com/posthog/posthog-python/commit/5ddb4464a634a1dddf9b585cb9cf804c671a2edf) Add propagated task context to active Celery OpenTelemetry spans. — Thanks @pauldambra!
+- [5ddb446](https://github.com/posthog/posthog-python/commit/5ddb4464a634a1dddf9b585cb9cf804c671a2edf) Add active PostHog request IDs to existing OpenTelemetry spans in ASGI middleware. — Thanks @pauldambra!
+
 ## 7.74.0 — 2026-10-21
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index bf1e6fa9c..1cd74dd98 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.74.0"
+VERSION = "7.75.0"
diff --git a/pyproject.toml b/pyproject.toml
index 753d86021..5d402c88f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.74.0"
+version = "7.75.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 7292cfbbc..79d2f1f5d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.113"
+version = "0.1.114"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.74.0"
+version = "7.75.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From a5b93eed7125a1ef7a9c9a442ec75487027f1f59 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:21:43 +0000
Subject: [PATCH 068/245] Update generated references

---
 .../posthog-python-references-7.75.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.0.json

diff --git a/references/posthog-python-references-7.75.0.json b/references/posthog-python-references-7.75.0.json
new file mode 100644
index 000000000..23d13e277
--- /dev/null
+++ b/references/posthog-python-references-7.75.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 2053aac41..23d13e277 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.74.0",
+    "version": "7.75.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From e9056e3051911b72aa1c8f9d39eb08fa4b0b65c4 Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Thu, 22 Oct 2026 15:49:48 +0700
Subject: [PATCH 069/245] fix(flags): match explicit null properties with
 string operators (#1092)

---
 .../pompous-guardian-joukahainen.md           |  5 +++
 posthog/feature_flags.py                      | 18 ++++------
 posthog/test/test_feature_flags.py            | 35 +++++++++++++++++++
 3 files changed, 47 insertions(+), 11 deletions(-)
 create mode 100644 .sampo/changesets/pompous-guardian-joukahainen.md

diff --git a/.sampo/changesets/pompous-guardian-joukahainen.md b/.sampo/changesets/pompous-guardian-joukahainen.md
new file mode 100644
index 000000000..e90ec2462
--- /dev/null
+++ b/.sampo/changesets/pompous-guardian-joukahainen.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Fix local feature flag string and regex operators to match an explicit null property as "null", like the flags service. This can change flag values or selected variants for explicitly null person or group properties. Missing properties still allow remote evaluation fallback.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index 7545306ea..049e2fe4e 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -698,6 +698,7 @@ def match_property(
 
     if (
         operator not in NONE_VALUES_ALLOWED_OPERATORS
+        and operator not in STRING_OPERATORS
         and operator != "exact"
         and override_value is None
     ):
@@ -750,17 +751,12 @@ def compute_exact_match(value, override_value):
             return not matched
         return matched
 
-    if operator == "regex":
-        return (
-            is_valid_regex(str(value))
-            and re.compile(str(value)).search(str(override_value)) is not None
-        )
-
-    if operator == "not_regex":
-        return (
-            is_valid_regex(str(value))
-            and re.compile(str(value)).search(str(override_value)) is None
-        )
+    if operator in ("regex", "not_regex"):
+        if not is_valid_regex(str(value)):
+            return False
+        property_string = "null" if override_value is None else str(override_value)
+        matched = re.compile(str(value)).search(property_string) is not None
+        return not matched if operator == "not_regex" else matched
 
     if operator in ["is_date_before", "is_date_after"]:
         try:
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index 374cb3259..2c430336d 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -5654,6 +5654,41 @@ def test_string_operators_preserve_float_stringification(
         prop = self.property("key", value, operator)
         self.assertTrue(match_property(prop, {"key": property_value}))
 
+    @parameterized.expand(
+        [
+            ("icontains", "nul", True),
+            ("icontains", "x", False),
+            ("not_icontains", "x", True),
+            ("not_icontains", "nul", False),
+            ("starts_with", "NU", True),
+            ("starts_with", "x", False),
+            ("not_starts_with", "x", True),
+            ("not_starts_with", "nu", False),
+            ("ends_with", "LL", True),
+            ("ends_with", "x", False),
+            ("not_ends_with", "x", True),
+            ("not_ends_with", "ll", False),
+            ("regex", "^nu", True),
+            ("regex", "Nu", False),
+            ("regex", "^None$", False),
+            ("regex", "x", False),
+            ("not_regex", "x", True),
+            ("not_regex", "^nu", False),
+            ("not_regex", "^None$", True),
+            ("regex", "[", False),
+            ("not_regex", "[", False),
+        ]
+    )
+    def test_string_operators_match_explicit_null(self, operator, value, expected):
+        prop = self.property("key", value, operator)
+        self.assertEqual(expected, match_property(prop, {"key": None}))
+
+    def test_string_operators_with_omitted_key_are_inconclusive(self):
+        for operator in posthog.feature_flags.STRING_OPERATORS:
+            with self.subTest(operator=operator):
+                with self.assertRaises(InconclusiveMatchError):
+                    match_property(self.property("key", "x", operator), {})
+
     def test_match_properties_regex(self):
         property_a = self.property(key="key", value=r"\.com$", operator="regex")
         self.assertTrue(match_property(property_a, {"key": "value.com"}))

From 361ca83dbf06c3f1674b4b2c5be05ffcc555191e Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 08:51:30 +0000
Subject: [PATCH 070/245] chore: Release v7.75.1 [skip ci]

---
 .sampo/changesets/pompous-guardian-joukahainen.md | 5 -----
 openfeature-provider/CHANGELOG.md                 | 6 ++++++
 openfeature-provider/pyproject.toml               | 2 +-
 posthog/CHANGELOG.md                              | 6 ++++++
 posthog/version.py                                | 2 +-
 pyproject.toml                                    | 2 +-
 uv.lock                                           | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/pompous-guardian-joukahainen.md

diff --git a/.sampo/changesets/pompous-guardian-joukahainen.md b/.sampo/changesets/pompous-guardian-joukahainen.md
deleted file mode 100644
index e90ec2462..000000000
--- a/.sampo/changesets/pompous-guardian-joukahainen.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Fix local feature flag string and regex operators to match an explicit null property as "null", like the flags service. This can change flag values or selected variants for explicitly null person or group properties. Missing properties still allow remote evaluation fallback.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index f33e39997..d388120dd 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.115 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.1
+
 ## 0.1.114 — 2026-10-21
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 6a9dd6b7e..37a5f8362 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.114"
+version = "0.1.115"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5421d4df4..e0ac0dbc8 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.1 — 2026-10-22
+
+### Patch changes
+
+- [e9056e3](https://github.com/posthog/posthog-python/commit/e9056e3051911b72aa1c8f9d39eb08fa4b0b65c4) Fix local feature flag string and regex operators to match an explicit null property as "null", like the flags service. This can change flag values or selected variants for explicitly null person or group properties. Missing properties still allow remote evaluation fallback. — Thanks @marandaneto!
+
 ## 7.75.0 — 2026-10-21
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 1cd74dd98..bf1cd1b6f 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.0"
+VERSION = "7.75.1"
diff --git a/pyproject.toml b/pyproject.toml
index 5d402c88f..97f0d71ec 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.0"
+version = "7.75.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 79d2f1f5d..6d889d246 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.114"
+version = "0.1.115"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.0"
+version = "7.75.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 5e296d88138157ee730916a293044e0c25fc7aef Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 08:51:36 +0000
Subject: [PATCH 071/245] Update generated references

---
 .../posthog-python-references-7.75.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.1.json

diff --git a/references/posthog-python-references-7.75.1.json b/references/posthog-python-references-7.75.1.json
new file mode 100644
index 000000000..738621f18
--- /dev/null
+++ b/references/posthog-python-references-7.75.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 23d13e277..738621f18 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.0",
+    "version": "7.75.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 4697e6fcc837d1de3508a8b53273f609b6d63415 Mon Sep 17 00:00:00 2001
From: mosafariuk <mosafariuk@gmail.com>
Date: Thu, 22 Oct 2026 11:08:25 +0100
Subject: [PATCH 072/245] fix(ai): capture OpenAI chat custom tool calls
 instead of raising (#1098)

A custom tool call has `custom` instead of `function`, so formatting the
response raised AttributeError from the wrapped create(), after the provider
call had succeeded. Read the name and input from `custom`, matching
PostHog/posthog-js#5251.
---
 .sampo/changesets/openai-custom-tool-calls.md |  5 ++
 posthog/ai/openai/openai_converter.py         | 14 ++-
 posthog/test/ai/openai/test_openai.py         | 86 +++++++++++++++++++
 3 files changed, 103 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/openai-custom-tool-calls.md

diff --git a/.sampo/changesets/openai-custom-tool-calls.md b/.sampo/changesets/openai-custom-tool-calls.md
new file mode 100644
index 000000000..49f5b66b6
--- /dev/null
+++ b/.sampo/changesets/openai-custom-tool-calls.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Capture Chat Completions responses that contain custom tool calls instead of raising `AttributeError` from the wrapped `create()` call.
diff --git a/posthog/ai/openai/openai_converter.py b/posthog/ai/openai/openai_converter.py
index 0f391fb9f..21c58478b 100644
--- a/posthog/ai/openai/openai_converter.py
+++ b/posthog/ai/openai/openai_converter.py
@@ -153,13 +153,23 @@ def format_openai_response(response: Any) -> List[FormattedMessage]:
 
                 if hasattr(choice.message, "tool_calls") and choice.message.tool_calls:
                     for tool_call in choice.message.tool_calls:
+                        # Custom tools carry their free-form text in `custom.input`,
+                        # with no `function` object.
+                        is_custom = getattr(tool_call, "type", None) == "custom"
+                        call = getattr(
+                            tool_call, "custom" if is_custom else "function", None
+                        )
+                        if call is None:
+                            continue
                         content.append(
                             {
                                 "type": "function",
                                 "id": tool_call.id,
                                 "function": {
-                                    "name": tool_call.function.name,
-                                    "arguments": tool_call.function.arguments,
+                                    "name": call.name,
+                                    "arguments": call.input
+                                    if is_custom
+                                    else call.arguments,
                                 },
                             }
                         )
diff --git a/posthog/test/ai/openai/test_openai.py b/posthog/test/ai/openai/test_openai.py
index 83304a4b1..a0a550191 100644
--- a/posthog/test/ai/openai/test_openai.py
+++ b/posthog/test/ai/openai/test_openai.py
@@ -736,6 +736,92 @@ def test_tool_calls_only_no_content(mock_client, mock_openai_response_tool_calls
         assert props["$ai_http_status"] == 200
 
 
+@pytest.mark.parametrize("is_async", [False, True])
+async def test_custom_tool_calls_are_captured(mock_client, is_async):
+    """A custom tool call has `custom` instead of `function`. The wrapped call
+    must return the completion and capture it, not raise AttributeError."""
+    completion = ChatCompletion.model_validate(
+        {
+            "id": "test",
+            "model": "gpt-5",
+            "object": "chat.completion",
+            "created": 0,
+            "choices": [
+                {
+                    "finish_reason": "tool_calls",
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "call_fn",
+                                "type": "function",
+                                "function": {
+                                    "name": "get_weather",
+                                    "arguments": '{"location": "New York"}',
+                                },
+                            },
+                            {
+                                "id": "call_custom",
+                                "type": "custom",
+                                "custom": {"name": "code_exec", "input": "print(1)"},
+                            },
+                        ],
+                    },
+                }
+            ],
+            "usage": {"prompt_tokens": 25, "completion_tokens": 10, "total_tokens": 35},
+        }
+    )
+    kwargs = dict(
+        model="gpt-5",
+        messages=[{"role": "user", "content": "Run it"}],
+        tools=[{"type": "custom", "custom": {"name": "code_exec"}}],
+        posthog_distinct_id="test-id",
+    )
+
+    if is_async:
+        with patch(
+            "openai.resources.chat.completions.AsyncCompletions.create",
+            new_callable=AsyncMock,
+            return_value=completion,
+        ):
+            client = AsyncOpenAI(api_key="test-key", posthog_client=mock_client)
+            response = await client.chat.completions.create(**kwargs)
+    else:
+        with patch(
+            "openai.resources.chat.completions.Completions.create",
+            return_value=completion,
+        ):
+            client = OpenAI(api_key="test-key", posthog_client=mock_client)
+            response = client.chat.completions.create(**kwargs)
+
+    assert response == completion
+    assert mock_client.capture.call_count == 1
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_output_choices"] == [
+        {
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "function",
+                    "id": "call_fn",
+                    "function": {
+                        "name": "get_weather",
+                        "arguments": '{"location": "New York"}',
+                    },
+                },
+                {
+                    "type": "function",
+                    "id": "call_custom",
+                    "function": {"name": "code_exec", "arguments": "print(1)"},
+                },
+            ],
+        }
+    ]
+
+
 def test_responses_api_tool_calls(mock_client, mock_responses_api_with_tool_calls):
     with patch(
         "openai.resources.responses.Responses.create",

From e63a898f2689be0b7a1f77c643ae5e62c5d25d15 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:10:48 +0000
Subject: [PATCH 073/245] chore: Release v7.75.2 [skip ci]

---
 .sampo/changesets/openai-custom-tool-calls.md | 5 -----
 openfeature-provider/CHANGELOG.md             | 6 ++++++
 openfeature-provider/pyproject.toml           | 2 +-
 posthog/CHANGELOG.md                          | 6 ++++++
 posthog/version.py                            | 2 +-
 pyproject.toml                                | 2 +-
 uv.lock                                       | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/openai-custom-tool-calls.md

diff --git a/.sampo/changesets/openai-custom-tool-calls.md b/.sampo/changesets/openai-custom-tool-calls.md
deleted file mode 100644
index 49f5b66b6..000000000
--- a/.sampo/changesets/openai-custom-tool-calls.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Capture Chat Completions responses that contain custom tool calls instead of raising `AttributeError` from the wrapped `create()` call.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index d388120dd..9e72ba64b 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.116 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.2
+
 ## 0.1.115 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 37a5f8362..bed9f7640 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.115"
+version = "0.1.116"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index e0ac0dbc8..8f249b1a0 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.2 — 2026-10-22
+
+### Patch changes
+
+- [4697e6f](https://github.com/posthog/posthog-python/commit/4697e6fcc837d1de3508a8b53273f609b6d63415) Capture Chat Completions responses that contain custom tool calls instead of raising `AttributeError` from the wrapped `create()` call. — Thanks @mosafariuk!
+
 ## 7.75.1 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index bf1cd1b6f..1f9f0be5a 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.1"
+VERSION = "7.75.2"
diff --git a/pyproject.toml b/pyproject.toml
index 97f0d71ec..2e2ef33c0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.1"
+version = "7.75.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 6d889d246..ea061b7e0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.115"
+version = "0.1.116"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.1"
+version = "7.75.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From e9710ec2817e5104e9f9a713acdd8734e9caf485 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:10:54 +0000
Subject: [PATCH 074/245] Update generated references

---
 .../posthog-python-references-7.75.2.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.2.json

diff --git a/references/posthog-python-references-7.75.2.json b/references/posthog-python-references-7.75.2.json
new file mode 100644
index 000000000..6b0cdcdf1
--- /dev/null
+++ b/references/posthog-python-references-7.75.2.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 738621f18..6b0cdcdf1 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.1",
+    "version": "7.75.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From dc2a2b4e33659e7909786fa48c625d37dc4da94d Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 22 Oct 2026 06:17:05 -0400
Subject: [PATCH 075/245] fix(ai): record mid-stream errors on streamed OpenAI,
 Anthropic and Gemini events (#1094)

* fix(ai): record mid-stream errors on streamed OpenAI, Anthropic and Gemini events

capture_streaming_event hard-coded $ai_http_status=200, and the stream
generators only had a finally block. When the provider stream raised after
the first chunk (overloaded, connection reset), the event was sent as a
success with no $ai_is_error/$ai_error, unlike the non-streaming path.

Catch the exception in each sync and async generator, pass it through
StreamingEventData, and re-raise unchanged. The event now carries
$ai_is_error, $ai_error and the error's status code (0 when it has none).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix(ai): pass the stream error to StreamingEventData directly and update the API snapshot

mypy 1.16 rejected splatting {"error": error} into StreamingEventData(...)
(typeddict-item). The field accepts None and capture_streaming_event reads it
with .get(), so pass error=error. Regenerate the public API snapshot for the new
StreamingEventData.error field.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../changesets/streaming-midstream-error.md   |   5 +
 posthog/ai/anthropic/anthropic.py             |   7 +
 posthog/ai/anthropic/anthropic_async.py       |   7 +
 posthog/ai/gemini/_shared.py                  |   2 +
 posthog/ai/gemini/gemini.py                   |   5 +
 posthog/ai/gemini/gemini_async.py             |   5 +
 posthog/ai/openai/_streaming.py               |   2 +
 posthog/ai/openai/openai.py                   |  14 +
 posthog/ai/openai/openai_async.py             |  14 +
 posthog/ai/types.py                           |   1 +
 posthog/ai/utils.py                           |   8 +-
 .../test/ai/test_stream_midstream_error.py    | 269 ++++++++++++++++++
 references/public_api_snapshot.txt            |   1 +
 13 files changed, 339 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/streaming-midstream-error.md
 create mode 100644 posthog/test/ai/test_stream_midstream_error.py

diff --git a/.sampo/changesets/streaming-midstream-error.md b/.sampo/changesets/streaming-midstream-error.md
new file mode 100644
index 000000000..b66920190
--- /dev/null
+++ b/.sampo/changesets/streaming-midstream-error.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Streamed OpenAI, Anthropic and Gemini generations that raise mid-stream are now captured with `$ai_is_error` and `$ai_error` (and the error's status code as `$ai_http_status`) instead of being recorded as a successful 200. The error is still re-raised to the caller, matching what non-streaming calls already did.
diff --git a/posthog/ai/anthropic/anthropic.py b/posthog/ai/anthropic/anthropic.py
index a474fefcf..704cacb20 100644
--- a/posthog/ai/anthropic/anthropic.py
+++ b/posthog/ai/anthropic/anthropic.py
@@ -188,10 +188,14 @@ def _track_streaming_response(
         accumulator = _AnthropicStreamAccumulator()
 
         def generator():
+            stream_error: Optional[BaseException] = None
             try:
                 for event in response:
                     accumulator.consume(event)
                     yield event
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 end_time = time.time()
                 latency = end_time - start_time
@@ -208,6 +212,7 @@ def generator():
                     accumulator.content_blocks,
                     accumulator.accumulated_content,
                     stop_reason=accumulator.stop_reason,
+                    error=stream_error,
                 )
 
         return _StreamWrapper(generator(), stream=response)
@@ -225,6 +230,7 @@ def _capture_streaming_event(
         content_blocks: List[StreamingContentBlock],
         accumulated_content: str,
         stop_reason: Optional[str] = None,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.types import StreamingEventData
         from posthog.ai.anthropic.anthropic_converter import (
@@ -252,6 +258,7 @@ def _capture_streaming_event(
             privacy_mode=posthog_privacy_mode,
             groups=posthog_groups,
             stop_reason=stop_reason,
+            error=error,
         )
 
         # Use the common capture function
diff --git a/posthog/ai/anthropic/anthropic_async.py b/posthog/ai/anthropic/anthropic_async.py
index 9ac091c64..5207fa6b4 100644
--- a/posthog/ai/anthropic/anthropic_async.py
+++ b/posthog/ai/anthropic/anthropic_async.py
@@ -188,10 +188,14 @@ def _track_streaming_response(
         accumulator = _AnthropicStreamAccumulator()
 
         async def generator():
+            stream_error: Optional[BaseException] = None
             try:
                 async for event in response:
                     accumulator.consume(event)
                     yield event
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 end_time = time.time()
                 latency = end_time - start_time
@@ -208,6 +212,7 @@ async def generator():
                     accumulator.content_blocks,
                     accumulator.accumulated_content,
                     stop_reason=accumulator.stop_reason,
+                    error=stream_error,
                 )
 
         return AsyncStreamWrapper(generator(), stream=response)
@@ -225,6 +230,7 @@ async def _capture_streaming_event(
         content_blocks: List[StreamingContentBlock],
         accumulated_content: str,
         stop_reason: Optional[str] = None,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.types import StreamingEventData
         from posthog.ai.anthropic.anthropic_converter import (
@@ -252,6 +258,7 @@ async def _capture_streaming_event(
             privacy_mode=posthog_privacy_mode,
             groups=posthog_groups,
             stop_reason=stop_reason,
+            error=error,
         )
 
         # Use the common capture function
diff --git a/posthog/ai/gemini/_shared.py b/posthog/ai/gemini/_shared.py
index fc3635589..e1036929d 100644
--- a/posthog/ai/gemini/_shared.py
+++ b/posthog/ai/gemini/_shared.py
@@ -203,6 +203,7 @@ def _capture_streaming_event(
         latency: float,
         output: Any,
         stop_reason: Optional[str] = None,
+        error: Optional[BaseException] = None,
     ) -> None:
         formatted_input = merge_system_prompt(
             {"contents": contents, **kwargs}, "gemini"
@@ -222,6 +223,7 @@ def _capture_streaming_event(
             privacy_mode=privacy_mode,
             groups=groups,
             stop_reason=stop_reason,
+            error=error,
         )
         capture_streaming_event(self._ph_client, event_data)
 
diff --git a/posthog/ai/gemini/gemini.py b/posthog/ai/gemini/gemini.py
index ff74bd270..c5006544a 100644
--- a/posthog/ai/gemini/gemini.py
+++ b/posthog/ai/gemini/gemini.py
@@ -266,6 +266,7 @@ def generator():
             nonlocal usage_stats
             nonlocal accumulated_content
             nonlocal stop_reason
+            stream_error: Optional[BaseException] = None
             try:
                 for chunk in response:
                     # Extract usage stats from chunk
@@ -288,6 +289,9 @@ def generator():
 
                     yield chunk
 
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 end_time = time.time()
                 latency = end_time - start_time
@@ -305,6 +309,7 @@ def generator():
                     latency,
                     accumulated_content,
                     stop_reason=stop_reason,
+                    error=stream_error,
                 )
 
         return generator()
diff --git a/posthog/ai/gemini/gemini_async.py b/posthog/ai/gemini/gemini_async.py
index edede3dca..0580b285b 100644
--- a/posthog/ai/gemini/gemini_async.py
+++ b/posthog/ai/gemini/gemini_async.py
@@ -253,6 +253,7 @@ async def async_generator():
             nonlocal accumulated_content
             nonlocal stop_reason
 
+            stream_error: Optional[BaseException] = None
             try:
                 async for chunk in response:
                     # Extract usage stats from chunk
@@ -275,6 +276,9 @@ async def async_generator():
 
                     yield chunk
 
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 end_time = time.time()
                 latency = end_time - start_time
@@ -292,6 +296,7 @@ async def async_generator():
                     latency,
                     accumulated_content,
                     stop_reason=stop_reason,
+                    error=stream_error,
                 )
 
         return AsyncStreamWrapper(async_generator(), stream=response)
diff --git a/posthog/ai/openai/_streaming.py b/posthog/ai/openai/_streaming.py
index 2ee95ec91..376372687 100644
--- a/posthog/ai/openai/_streaming.py
+++ b/posthog/ai/openai/_streaming.py
@@ -102,6 +102,7 @@ def _build_streaming_event_data(
     model_from_response: Optional[str],
     stop_reason: Optional[str],
     service_tier: Optional[str] = None,
+    error: Optional[BaseException] = None,
 ) -> StreamingEventData:
     """Build the fields shared by both OpenAI streaming endpoint events."""
 
@@ -121,4 +122,5 @@ def _build_streaming_event_data(
         groups=groups,
         stop_reason=stop_reason,
         service_tier=service_tier,
+        error=error,
     )
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index ea00a197b..ccdf6e69a 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -170,10 +170,14 @@ def _create_streaming(
         response = self._original.create(**kwargs)
 
         def generator():
+            stream_error: Optional[BaseException] = None
             try:
                 for chunk in response:
                     state.process_chunk(chunk)
                     yield chunk
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 self._capture_streaming_event(
                     posthog_distinct_id,
@@ -184,6 +188,7 @@ def generator():
                     kwargs,
                     state,
                     time.time() - start_time,
+                    error=stream_error,
                 )
 
         return _StreamWrapper(generator(), stream=response)
@@ -198,6 +203,7 @@ def _capture_streaming_event(
         kwargs: Dict[str, Any],
         state: _ResponsesStreamState,
         latency: float,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.utils import capture_streaming_event
 
@@ -216,6 +222,7 @@ def _capture_streaming_event(
             model_from_response=state.model,
             stop_reason=state.stop_reason,
             service_tier=state.service_tier,
+            error=error,
         )
         capture_streaming_event(self._client._ph_client, event_data)
 
@@ -388,10 +395,14 @@ def _create_streaming(
         response = self._original.create(**kwargs)
 
         def generator():
+            stream_error: Optional[BaseException] = None
             try:
                 for chunk in response:
                     state.process_chunk(chunk)
                     yield chunk
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 self._capture_streaming_event(
                     posthog_distinct_id,
@@ -402,6 +413,7 @@ def generator():
                     kwargs,
                     state,
                     time.time() - start_time,
+                    error=stream_error,
                 )
 
         return _StreamWrapper(generator(), stream=response)
@@ -416,6 +428,7 @@ def _capture_streaming_event(
         kwargs: Dict[str, Any],
         state: _ChatCompletionsStreamState,
         latency: float,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.utils import capture_streaming_event
 
@@ -436,6 +449,7 @@ def _capture_streaming_event(
             model_from_response=state.model,
             stop_reason=state.stop_reason,
             service_tier=state.service_tier,
+            error=error,
         )
         capture_streaming_event(self._client._ph_client, event_data)
 
diff --git a/posthog/ai/openai/openai_async.py b/posthog/ai/openai/openai_async.py
index dac3eeb4a..07e0de670 100644
--- a/posthog/ai/openai/openai_async.py
+++ b/posthog/ai/openai/openai_async.py
@@ -171,10 +171,14 @@ async def _create_streaming(
         response = await self._original.create(**kwargs)
 
         async def async_generator():
+            stream_error: Optional[BaseException] = None
             try:
                 async for chunk in response:
                     state.process_chunk(chunk)
                     yield chunk
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 await self._capture_streaming_event(
                     posthog_distinct_id,
@@ -185,6 +189,7 @@ async def async_generator():
                     kwargs,
                     state,
                     time.time() - start_time,
+                    error=stream_error,
                 )
 
         return AsyncStreamWrapper(async_generator(), stream=response)
@@ -199,6 +204,7 @@ async def _capture_streaming_event(
         kwargs: Dict[str, Any],
         state: _ResponsesStreamState,
         latency: float,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.utils import capture_streaming_event
 
@@ -217,6 +223,7 @@ async def _capture_streaming_event(
             model_from_response=state.model,
             stop_reason=state.stop_reason,
             service_tier=state.service_tier,
+            error=error,
         )
         capture_streaming_event(self._client._ph_client, event_data)
 
@@ -392,10 +399,14 @@ async def _create_streaming(
         response = await self._original.create(**kwargs)
 
         async def async_generator():
+            stream_error: Optional[BaseException] = None
             try:
                 async for chunk in response:
                     state.process_chunk(chunk)
                     yield chunk
+            except Exception as exc:
+                stream_error = exc
+                raise
             finally:
                 await self._capture_streaming_event(
                     posthog_distinct_id,
@@ -406,6 +417,7 @@ async def async_generator():
                     kwargs,
                     state,
                     time.time() - start_time,
+                    error=stream_error,
                 )
 
         return AsyncStreamWrapper(async_generator(), stream=response)
@@ -420,6 +432,7 @@ async def _capture_streaming_event(
         kwargs: Dict[str, Any],
         state: _ChatCompletionsStreamState,
         latency: float,
+        error: Optional[BaseException] = None,
     ):
         from posthog.ai.utils import capture_streaming_event
 
@@ -440,6 +453,7 @@ async def _capture_streaming_event(
             model_from_response=state.model,
             stop_reason=state.stop_reason,
             service_tier=state.service_tier,
+            error=error,
         )
         capture_streaming_event(self._client._ph_client, event_data)
 
diff --git a/posthog/ai/types.py b/posthog/ai/types.py
index 36424b133..1fc5555fa 100644
--- a/posthog/ai/types.py
+++ b/posthog/ai/types.py
@@ -143,3 +143,4 @@ class StreamingEventData(TypedDict):
     groups: Optional[Dict[str, Any]]
     stop_reason: Optional[str]
     service_tier: NotRequired[Optional[str]]
+    error: NotRequired[Optional[BaseException]]  # raised mid-stream, if any
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index c943bcc28..5f2b956e0 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -837,6 +837,7 @@ def capture_streaming_event(
         event_data: Standardized streaming event data containing all necessary information
     """
     trace_id = event_data.get("trace_id") or str(uuid.uuid4())
+    error = event_data.get("error")
 
     # Omitted when the provider never reported a count: absent means unknown,
     # 0 is a report of nothing. An interrupted stream often reports neither.
@@ -865,13 +866,18 @@ def capture_streaming_event(
             event_data["privacy_mode"],
             finalize_ai_content(event_data["formatted_output"], ph_client),
         ),
-        "$ai_http_status": 200,
+        "$ai_http_status": (
+            getattr(error, "status_code", 0) if error is not None else 200
+        ),
         **({"$ai_input_tokens": input_tokens} if input_tokens is not None else {}),
         **({"$ai_output_tokens": output_tokens} if output_tokens is not None else {}),
         "$ai_latency": event_data["latency"],
         "$ai_trace_id": trace_id,
         "$ai_base_url": str(event_data["base_url"]),
         **(event_data.get("properties") or {}),
+        **(
+            {"$ai_is_error": True, "$ai_error": str(error)} if error is not None else {}
+        ),
     }
 
     warn_if_posthog_ai_gateway(event_data["base_url"])
diff --git a/posthog/test/ai/test_stream_midstream_error.py b/posthog/test/ai/test_stream_midstream_error.py
new file mode 100644
index 000000000..1fbc8278f
--- /dev/null
+++ b/posthog/test/ai/test_stream_midstream_error.py
@@ -0,0 +1,269 @@
+"""A stream that raises mid-flight must be captured as an error, not as a 200."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from posthog.ai.types import StreamingEventData
+from posthog.ai.utils import capture_streaming_event
+
+
+@pytest.fixture
+def mock_client():
+    with patch("posthog.client.Client") as mock_client:
+        mock_client.privacy_mode = False
+        yield mock_client
+
+
+def _props(mock_client):
+    assert mock_client.capture.call_count == 1
+    return mock_client.capture.call_args[1]["properties"]
+
+
+class _StatusError(RuntimeError):
+    status_code = 529
+
+
+def _event_data(**overrides) -> StreamingEventData:
+    data = StreamingEventData(
+        provider="openai",
+        model="gpt-4",
+        base_url="https://api.openai.com/v1",
+        kwargs={},
+        formatted_input=[],
+        formatted_output=[],
+        usage_stats={},
+        latency=0.1,
+        distinct_id="id",
+        trace_id="trace",
+        properties=None,
+        privacy_mode=False,
+        groups=None,
+        stop_reason=None,
+    )
+    data.update(overrides)
+    return data
+
+
+def test_capture_streaming_event_without_error_is_ok(mock_client):
+    capture_streaming_event(mock_client, _event_data())
+    props = _props(mock_client)
+    assert props["$ai_http_status"] == 200
+    assert "$ai_is_error" not in props
+
+
+@pytest.mark.parametrize(
+    "error, status", [(RuntimeError("boom"), 0), (_StatusError("overloaded"), 529)]
+)
+def test_capture_streaming_event_with_error(mock_client, error, status):
+    capture_streaming_event(mock_client, _event_data(error=error))
+    props = _props(mock_client)
+    assert props["$ai_http_status"] == status
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == str(error)
+
+
+def test_openai_chat_stream_error(mock_client):
+    from openai.types.chat import ChatCompletionChunk
+    from openai.types.chat.chat_completion_chunk import Choice, ChoiceDelta
+
+    from posthog.ai.openai import OpenAI
+
+    chunk = ChatCompletionChunk(
+        id="c1",
+        created=1,
+        model="gpt-4",
+        object="chat.completion.chunk",
+        choices=[Choice(index=0, delta=ChoiceDelta(content="partial"))],
+    )
+
+    def stream():
+        yield chunk
+        raise RuntimeError("connection reset")
+
+    with patch("openai.resources.chat.completions.Completions.create") as create:
+        create.return_value = stream()
+        client = OpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(RuntimeError, match="connection reset"):
+            list(
+                client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": "hi"}],
+                    stream=True,
+                )
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "connection reset"
+    assert props["$ai_http_status"] == 0
+
+
+@pytest.mark.asyncio
+async def test_openai_chat_stream_error_async(mock_client):
+    from openai.types.chat import ChatCompletionChunk
+    from openai.types.chat.chat_completion_chunk import Choice, ChoiceDelta
+
+    from posthog.ai.openai import AsyncOpenAI
+
+    chunk = ChatCompletionChunk(
+        id="c1",
+        created=1,
+        model="gpt-4",
+        object="chat.completion.chunk",
+        choices=[Choice(index=0, delta=ChoiceDelta(content="partial"))],
+    )
+
+    async def stream():
+        yield chunk
+        raise RuntimeError("connection reset")
+
+    async def create(self, **kwargs):
+        return stream()
+
+    with patch("openai.resources.chat.completions.AsyncCompletions.create", new=create):
+        client = AsyncOpenAI(api_key="k", posthog_client=mock_client)
+        response = await client.chat.completions.create(
+            model="gpt-4", messages=[{"role": "user", "content": "hi"}], stream=True
+        )
+        with pytest.raises(RuntimeError, match="connection reset"):
+            async for _ in response:
+                pass
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 0
+
+
+def test_openai_responses_stream_error(mock_client):
+    from posthog.ai.openai import OpenAI
+
+    def stream():
+        yield MagicMock(type="response.created", response=None)
+        raise RuntimeError("connection reset")
+
+    with patch("openai.resources.responses.Responses.create") as create:
+        create.return_value = stream()
+        client = OpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(RuntimeError, match="connection reset"):
+            list(client.responses.create(model="gpt-4", input="hi", stream=True))
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "connection reset"
+
+
+def test_anthropic_stream_error(mock_client):
+    from posthog.ai.anthropic import Anthropic
+
+    def stream():
+        yield MagicMock(type="message_start", message=None)
+        raise _StatusError("overloaded")
+
+    with patch("anthropic.resources.messages.Messages.create") as create:
+        create.return_value = stream()
+        client = Anthropic(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_StatusError):
+            list(
+                client.messages.create(
+                    model="claude-3-opus-20240229",
+                    messages=[{"role": "user", "content": "hi"}],
+                    max_tokens=5,
+                    stream=True,
+                )
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 529
+
+
+@pytest.mark.asyncio
+async def test_anthropic_stream_error_async(mock_client):
+    from posthog.ai.anthropic import AsyncAnthropic
+
+    async def stream():
+        yield MagicMock(type="message_start", message=None)
+        raise _StatusError("overloaded")
+
+    async def create(**kwargs):
+        return stream()
+
+    with patch("anthropic.resources.messages.AsyncMessages.create", side_effect=create):
+        client = AsyncAnthropic(api_key="k", posthog_client=mock_client)
+        response = await client.messages.create(
+            model="claude-3-opus-20240229",
+            messages=[{"role": "user", "content": "hi"}],
+            max_tokens=5,
+            stream=True,
+        )
+        with pytest.raises(_StatusError):
+            async for _ in response:
+                pass
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 529
+
+
+def _gemini_chunk():
+    chunk = MagicMock()
+    chunk.text = "partial"
+    chunk.usage_metadata = None
+    return chunk
+
+
+def test_gemini_stream_error(mock_client):
+    pytest.importorskip("google.genai")
+    from google import genai as google_genai
+
+    from posthog.ai.gemini import Client
+
+    def stream():
+        yield _gemini_chunk()
+        raise RuntimeError("503 overloaded mid-stream")
+
+    with patch.object(google_genai, "Client") as cls:
+        inst = MagicMock()
+        cls.return_value = inst
+        inst.models.generate_content_stream.return_value = stream()
+        client = Client(api_key="k", posthog_client=mock_client)
+        with pytest.raises(RuntimeError, match="503"):
+            list(
+                client.models.generate_content_stream(
+                    model="gemini-2.0-flash", contents=["hi"]
+                )
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "503 overloaded mid-stream"
+    assert props["$ai_http_status"] == 0
+
+
+@pytest.mark.asyncio
+async def test_gemini_stream_error_async(mock_client):
+    pytest.importorskip("google.genai")
+    from google import genai as google_genai
+
+    from posthog.ai.gemini import AsyncClient
+
+    async def stream():
+        yield _gemini_chunk()
+        raise RuntimeError("503 overloaded mid-stream")
+
+    with patch.object(google_genai, "Client") as cls:
+        inst = MagicMock()
+        cls.return_value = inst
+        inst.aio.models.generate_content_stream = AsyncMock(return_value=stream())
+        client = AsyncClient(api_key="k", posthog_client=mock_client)
+        response = await client.models.generate_content_stream(
+            model="gemini-2.0-flash", contents=["hi"]
+        )
+        with pytest.raises(RuntimeError, match="503"):
+            async for _ in response:
+                pass
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 0
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index c745fa8b6..dc2bbe85f 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -680,6 +680,7 @@ attribute posthog.ai.types.StreamingContentBlock.thinking: Optional[str]
 attribute posthog.ai.types.StreamingContentBlock.type: str
 attribute posthog.ai.types.StreamingEventData.base_url: str
 attribute posthog.ai.types.StreamingEventData.distinct_id: Optional[str]
+attribute posthog.ai.types.StreamingEventData.error: NotRequired[Optional[BaseException]]
 attribute posthog.ai.types.StreamingEventData.formatted_input: Any
 attribute posthog.ai.types.StreamingEventData.formatted_output: Any
 attribute posthog.ai.types.StreamingEventData.groups: Optional[Dict[str, Any]]

From 42c8b7bc1ba1b1acca1b931830ded4818b26df33 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 22 Oct 2026 06:17:28 -0400
Subject: [PATCH 076/245] fix(ai): keep the refusal of a non-streamed OpenAI
 chat completion in the captured output (#1095)

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../changesets/openai-chat-refusal-output.md  |  5 +++
 posthog/ai/openai/openai_converter.py         |  5 +++
 .../test/ai/openai/test_openai_converter.py   | 31 +++++++++++++++++++
 3 files changed, 41 insertions(+)
 create mode 100644 .sampo/changesets/openai-chat-refusal-output.md

diff --git a/.sampo/changesets/openai-chat-refusal-output.md b/.sampo/changesets/openai-chat-refusal-output.md
new file mode 100644
index 000000000..4d222d4d2
--- /dev/null
+++ b/.sampo/changesets/openai-chat-refusal-output.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+A non-streamed OpenAI chat completion that the model refused is no longer captured with an empty `$ai_output_choices`: the refusal text is recorded as a `refusal` content block, as it already is for streamed responses.
diff --git a/posthog/ai/openai/openai_converter.py b/posthog/ai/openai/openai_converter.py
index 21c58478b..e0f397ff6 100644
--- a/posthog/ai/openai/openai_converter.py
+++ b/posthog/ai/openai/openai_converter.py
@@ -151,6 +151,11 @@ def format_openai_response(response: Any) -> List[FormattedMessage]:
                         }
                     )
 
+                # A refused request carries its text in `refusal` and leaves `content` empty
+                refusal = getattr(choice.message, "refusal", None)
+                if refusal:
+                    content.append({"type": "refusal", "refusal": refusal})
+
                 if hasattr(choice.message, "tool_calls") and choice.message.tool_calls:
                     for tool_call in choice.message.tool_calls:
                         # Custom tools carry their free-form text in `custom.input`,
diff --git a/posthog/test/ai/openai/test_openai_converter.py b/posthog/test/ai/openai/test_openai_converter.py
index e23ecac87..a6ee44e6b 100644
--- a/posthog/test/ai/openai/test_openai_converter.py
+++ b/posthog/test/ai/openai/test_openai_converter.py
@@ -82,6 +82,37 @@ def test_message_object_does_not_crash():
     assert out[1]["content"] == "hello"
 
 
+def test_chat_response_keeps_refusal():
+    """A refused chat completion has no content, only message.refusal, and used to be captured as []."""
+    from openai.types.chat import ChatCompletion
+    from openai.types.chat.chat_completion import Choice
+
+    from posthog.ai.openai.openai_converter import format_openai_response
+
+    response = ChatCompletion(
+        id="chatcmpl-1",
+        object="chat.completion",
+        created=0,
+        model="gpt-4o",
+        choices=[
+            Choice(
+                index=0,
+                finish_reason="stop",
+                message=ChatCompletionMessage(
+                    role="assistant", content=None, refusal="I can't help with that"
+                ),
+            )
+        ],
+    )
+
+    assert format_openai_response(response) == [
+        {
+            "role": "assistant",
+            "content": [{"type": "refusal", "refusal": "I can't help with that"}],
+        }
+    ]
+
+
 def test_responses_output_keeps_all_items():
     from posthog.ai.openai.openai_converter import format_openai_response
 

From a6ddc2ed3227a1f8efa170f3eb7fce5b9aef36db Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 22 Oct 2026 06:18:07 -0400
Subject: [PATCH 077/245] fix(ai): record an integer $ai_http_status in the
 LangChain callback handler (#1096)

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../changesets/langchain-http-status-int.md   |  5 ++
 posthog/ai/langchain/callbacks.py             |  8 ++-
 posthog/test/ai/langchain/test_callbacks.py   | 61 +++++++++++++++++++
 3 files changed, 72 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/langchain-http-status-int.md

diff --git a/.sampo/changesets/langchain-http-status-int.md b/.sampo/changesets/langchain-http-status-int.md
new file mode 100644
index 000000000..37e2f623c
--- /dev/null
+++ b/.sampo/changesets/langchain-http-status-int.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+The LangChain callback handler now records `$ai_http_status` as an integer for failed generations. An error that carries a string `code` and no status code (such as OpenAI's `rate_limit_exceeded`) gave a string status; it now gives `0`, as an error without a status already did.
diff --git a/posthog/ai/langchain/callbacks.py b/posthog/ai/langchain/callbacks.py
index 3b9e188b0..5f996fb6c 100644
--- a/posthog/ai/langchain/callbacks.py
+++ b/posthog/ai/langchain/callbacks.py
@@ -1036,8 +1036,12 @@ def _get_http_status(error: BaseException) -> int:
     # OpenAI: https://github.com/openai/openai-python/blob/main/src/openai/_exceptions.py
     # Anthropic: https://github.com/anthropics/anthropic-sdk-python/blob/main/src/anthropic/_exceptions.py
     # Google: https://github.com/googleapis/python-api-core/blob/main/google/api_core/exceptions.py
-    status_code = getattr(error, "status_code", getattr(error, "code", 0))
-    return status_code
+    # `code` is a string on some errors (OpenAI's "rate_limit_exceeded"), so only ints count
+    for attribute in ("status_code", "code"):
+        value = getattr(error, attribute, None)
+        if isinstance(value, int) and not isinstance(value, bool):
+            return value
+    return 0
 
 
 def _get_langchain_run_name(
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index 2556294ae..b33e154fc 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -2953,3 +2953,64 @@ def test_stop_reason_resolution(
 
     props = mock_client.capture.call_args.kwargs["properties"]
     assert props.get("$ai_stop_reason") == expected
+
+
+class TestGetHttpStatus:
+    def test_uses_the_status_code_of_an_http_error(self):
+        from posthog.ai.langchain.callbacks import _get_http_status
+
+        error = Exception("rate limited")
+        error.status_code = 429  # type: ignore[attr-defined]
+
+        assert _get_http_status(error) == 429
+
+    def test_uses_an_integer_code_when_there_is_no_status_code(self):
+        from posthog.ai.langchain.callbacks import _get_http_status
+
+        error = Exception("quota")
+        error.code = 503  # type: ignore[attr-defined]
+
+        assert _get_http_status(error) == 503
+
+    def test_ignores_a_string_code(self):
+        """OpenAI's APIError carries code="rate_limit_exceeded" and no status code."""
+        from posthog.ai.langchain.callbacks import _get_http_status
+
+        error = Exception("Rate limit reached")
+        error.code = "rate_limit_exceeded"  # type: ignore[attr-defined]
+
+        assert _get_http_status(error) == 0
+
+    def test_falls_back_to_zero_without_a_status(self):
+        from posthog.ai.langchain.callbacks import _get_http_status
+
+        assert _get_http_status(Exception("boom")) == 0
+
+    def test_an_error_event_records_an_integer_status(self):
+        import httpx
+        import openai
+        from unittest.mock import MagicMock
+        from uuid import uuid4
+
+        from posthog.ai.langchain import CallbackHandler
+
+        client = MagicMock()
+        client.privacy_mode = False
+        callback = CallbackHandler(client)
+        run_id = uuid4()
+        callback._set_llm_metadata(
+            serialized={},
+            run_id=run_id,
+            messages=[{"role": "user", "content": "test"}],
+            metadata={"ls_provider": "openai", "ls_model_name": "gpt-5.6-sol"},
+        )
+        error = openai.APIError(
+            "Rate limit reached",
+            request=httpx.Request("POST", "https://api.openai.com/v1/chat/completions"),
+            body={"code": "rate_limit_exceeded", "message": "Rate limit reached"},
+        )
+
+        callback._pop_run_and_capture_generation(run_id, None, error)
+
+        properties = client.capture.call_args_list[0][1]["properties"]
+        assert properties["$ai_http_status"] == 0

From dc0126690696694809d3c5ff3785f142c509e4fb Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:21:18 +0000
Subject: [PATCH 078/245] chore: Release v7.75.3 [skip ci]

---
 .sampo/changesets/langchain-http-status-int.md  | 5 -----
 .sampo/changesets/openai-chat-refusal-output.md | 5 -----
 .sampo/changesets/streaming-midstream-error.md  | 5 -----
 openfeature-provider/CHANGELOG.md               | 6 ++++++
 openfeature-provider/pyproject.toml             | 2 +-
 posthog/CHANGELOG.md                            | 8 ++++++++
 posthog/version.py                              | 2 +-
 pyproject.toml                                  | 2 +-
 uv.lock                                         | 4 ++--
 9 files changed, 19 insertions(+), 20 deletions(-)
 delete mode 100644 .sampo/changesets/langchain-http-status-int.md
 delete mode 100644 .sampo/changesets/openai-chat-refusal-output.md
 delete mode 100644 .sampo/changesets/streaming-midstream-error.md

diff --git a/.sampo/changesets/langchain-http-status-int.md b/.sampo/changesets/langchain-http-status-int.md
deleted file mode 100644
index 37e2f623c..000000000
--- a/.sampo/changesets/langchain-http-status-int.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-The LangChain callback handler now records `$ai_http_status` as an integer for failed generations. An error that carries a string `code` and no status code (such as OpenAI's `rate_limit_exceeded`) gave a string status; it now gives `0`, as an error without a status already did.
diff --git a/.sampo/changesets/openai-chat-refusal-output.md b/.sampo/changesets/openai-chat-refusal-output.md
deleted file mode 100644
index 4d222d4d2..000000000
--- a/.sampo/changesets/openai-chat-refusal-output.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-A non-streamed OpenAI chat completion that the model refused is no longer captured with an empty `$ai_output_choices`: the refusal text is recorded as a `refusal` content block, as it already is for streamed responses.
diff --git a/.sampo/changesets/streaming-midstream-error.md b/.sampo/changesets/streaming-midstream-error.md
deleted file mode 100644
index b66920190..000000000
--- a/.sampo/changesets/streaming-midstream-error.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Streamed OpenAI, Anthropic and Gemini generations that raise mid-stream are now captured with `$ai_is_error` and `$ai_error` (and the error's status code as `$ai_http_status`) instead of being recorded as a successful 200. The error is still re-raised to the caller, matching what non-streaming calls already did.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 9e72ba64b..4672bcd96 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.117 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.3
+
 ## 0.1.116 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index bed9f7640..48d8ea70a 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.116"
+version = "0.1.117"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 8f249b1a0..78146af1b 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,13 @@
 # posthog
 
+## 7.75.3 — 2026-10-22
+
+### Patch changes
+
+- [a6ddc2e](https://github.com/posthog/posthog-python/commit/a6ddc2ed3227a1f8efa170f3eb7fce5b9aef36db) The LangChain callback handler now records `$ai_http_status` as an integer for failed generations. An error that carries a string `code` and no status code (such as OpenAI's `rate_limit_exceeded`) gave a string status; it now gives `0`, as an error without a status already did. — Thanks @pcbeingused333 for your first contribution 🎉!
+- [42c8b7b](https://github.com/posthog/posthog-python/commit/42c8b7bc1ba1b1acca1b931830ded4818b26df33) A non-streamed OpenAI chat completion that the model refused is no longer captured with an empty `$ai_output_choices`: the refusal text is recorded as a `refusal` content block, as it already is for streamed responses. — Thanks @pcbeingused333 for your first contribution 🎉!
+- [dc2a2b4](https://github.com/posthog/posthog-python/commit/dc2a2b4e33659e7909786fa48c625d37dc4da94d) Streamed OpenAI, Anthropic and Gemini generations that raise mid-stream are now captured with `$ai_is_error` and `$ai_error` (and the error's status code as `$ai_http_status`) instead of being recorded as a successful 200. The error is still re-raised to the caller, matching what non-streaming calls already did. — Thanks @pcbeingused333 for your first contribution 🎉!
+
 ## 7.75.2 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 1f9f0be5a..c05dfc087 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.2"
+VERSION = "7.75.3"
diff --git a/pyproject.toml b/pyproject.toml
index 2e2ef33c0..91691ca73 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.2"
+version = "7.75.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index ea061b7e0..afdfd2f8e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.116"
+version = "0.1.117"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.2"
+version = "7.75.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 9185524005c394e78a977092dcf9fcb7885160dc Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:21:23 +0000
Subject: [PATCH 079/245] Update generated references

---
 .../posthog-python-references-7.75.3.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.3.json

diff --git a/references/posthog-python-references-7.75.3.json b/references/posthog-python-references-7.75.3.json
new file mode 100644
index 000000000..03f87f17f
--- /dev/null
+++ b/references/posthog-python-references-7.75.3.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 6b0cdcdf1..03f87f17f 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.2",
+    "version": "7.75.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 34ec4f828a45728c91e452e960aa0119a3052812 Mon Sep 17 00:00:00 2001
From: Harsh Kashyap <55448981+Harsh23Kashyap@users.noreply.github.com>
Date: Thu, 22 Oct 2026 16:00:08 +0530
Subject: [PATCH 080/245] fix(ai): keep latest cumulative output tokens across
 message_deltas (#1100)

* fix(ai): keep latest cumulative output tokens across message_deltas

Server tools such as web search can emit several message_delta events in
one Anthropic stream, and each delta's usage is cumulative. The stream
accumulator added every delta's output_tokens together, so a stream with
two deltas reporting 50 then 110 cumulative tokens captured 160. Keep
the latest cumulative value, matching how the input and cache counts are
already handled and how the Anthropic SDK accumulates usage.

* style(ai): format cumulative token async regression test

---------

Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .../cumulative-delta-output-tokens.md         |  5 ++
 posthog/ai/anthropic/_anthropic_stream.py     | 10 ++-
 posthog/test/ai/anthropic/test_anthropic.py   | 81 +++++++++++++++++++
 3 files changed, 95 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/cumulative-delta-output-tokens.md

diff --git a/.sampo/changesets/cumulative-delta-output-tokens.md b/.sampo/changesets/cumulative-delta-output-tokens.md
new file mode 100644
index 000000000..cbc8bc720
--- /dev/null
+++ b/.sampo/changesets/cumulative-delta-output-tokens.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Streamed Anthropic generations no longer stack output tokens when a stream emits more than one `message_delta` (server tools can send several). Each delta's usage is cumulative, so the accumulator now keeps the latest total instead of adding every delta together.
diff --git a/posthog/ai/anthropic/_anthropic_stream.py b/posthog/ai/anthropic/_anthropic_stream.py
index ff3fbe0b8..2df160ef8 100644
--- a/posthog/ai/anthropic/_anthropic_stream.py
+++ b/posthog/ai/anthropic/_anthropic_stream.py
@@ -53,7 +53,15 @@ def consume(self, event: Any) -> None:
         event_usage = extract_anthropic_usage_from_event(event)
         merge_usage_stats(self.usage_stats, event_usage)
         if getattr(event, "type", None) == "message_delta":
-            self._apply_cumulative_input_usage(getattr(event, "usage", None))
+            usage = getattr(event, "usage", None)
+            self._apply_cumulative_input_usage(usage)
+            output_tokens = getattr(usage, "output_tokens", None)
+            if isinstance(output_tokens, int) and not isinstance(output_tokens, bool):
+                # output_tokens on a message_delta is cumulative too, so the
+                # incremental merge above must not stack successive deltas
+                # (server tools can emit several in one stream). Keep the
+                # latest total; a field the event omits leaves the prior one.
+                self.usage_stats["output_tokens"] = output_tokens
 
         if getattr(event, "type", None) == "content_block_start":
             block, tool = handle_anthropic_content_block_start(event)
diff --git a/posthog/test/ai/anthropic/test_anthropic.py b/posthog/test/ai/anthropic/test_anthropic.py
index 08c66e7e2..ffc6feeed 100644
--- a/posthog/test/ai/anthropic/test_anthropic.py
+++ b/posthog/test/ai/anthropic/test_anthropic.py
@@ -907,6 +907,87 @@ async def mock_async_create(**kwargs):
     assert_cumulative_delta_usage(mock_client.capture.call_args.kwargs["properties"])
 
 
+def anthropic_stream_with_two_cumulative_deltas():
+    # Server tools can emit more than one message_delta in a single stream,
+    # and each delta's usage is cumulative: later values replace earlier ones
+    # rather than adding to them.
+    return [
+        RawMessageStartEvent(
+            type="message_start",
+            message=Message(
+                id="msg_1",
+                type="message",
+                role="assistant",
+                model="claude-haiku-4-5",
+                content=[],
+                stop_reason=None,
+                stop_sequence=None,
+                usage=Usage(
+                    input_tokens=100,
+                    output_tokens=1,
+                    cache_creation_input_tokens=0,
+                    cache_read_input_tokens=0,
+                ),
+            ),
+        ),
+        RawMessageDeltaEvent(
+            type="message_delta",
+            delta=Delta(stop_reason="pause_turn", stop_sequence=None),
+            usage=MessageDeltaUsage(output_tokens=50),
+        ),
+        RawMessageDeltaEvent(
+            type="message_delta",
+            delta=Delta(stop_reason="end_turn", stop_sequence=None),
+            usage=MessageDeltaUsage(output_tokens=110),
+        ),
+        RawMessageStopEvent(type="message_stop"),
+    ]
+
+
+def test_streaming_multiple_message_deltas_do_not_stack_output_tokens(mock_client):
+    with patch(
+        "anthropic.resources.Messages.create",
+        return_value=iter(anthropic_stream_with_two_cumulative_deltas()),
+    ):
+        client = Anthropic(api_key="test-key", posthog_client=mock_client)
+        response = client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        list(response)
+
+    props = mock_client.capture.call_args.kwargs["properties"]
+    assert props["$ai_output_tokens"] == 110
+
+
+@pytest.mark.asyncio
+async def test_streaming_multiple_message_deltas_do_not_stack_output_tokens_async(
+    mock_client,
+):
+    async def mock_async_stream():
+        for event in anthropic_stream_with_two_cumulative_deltas():
+            yield event
+
+    async def mock_async_create(**kwargs):
+        return mock_async_stream()
+
+    with patch(
+        "anthropic.resources.messages.AsyncMessages.create",
+        side_effect=mock_async_create,
+    ):
+        client = AsyncAnthropic(api_key="test-key", posthog_client=mock_client)
+        response = await client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        [event async for event in response]
+
+    props = mock_client.capture.call_args.kwargs["properties"]
+    assert props["$ai_output_tokens"] == 110
+
+
 def test_anthropic_bedrock_preserves_cache_creation_ttl_breakdown(
     mock_client, mock_anthropic_response_with_cache_ttl
 ):

From 84664b48304ff81c68ae5ed0a92e938a27d22a46 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:39:43 +0000
Subject: [PATCH 081/245] chore: Release v7.75.4 [skip ci]

---
 .sampo/changesets/cumulative-delta-output-tokens.md | 5 -----
 openfeature-provider/CHANGELOG.md                   | 6 ++++++
 openfeature-provider/pyproject.toml                 | 2 +-
 posthog/CHANGELOG.md                                | 6 ++++++
 posthog/version.py                                  | 2 +-
 pyproject.toml                                      | 2 +-
 uv.lock                                             | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/cumulative-delta-output-tokens.md

diff --git a/.sampo/changesets/cumulative-delta-output-tokens.md b/.sampo/changesets/cumulative-delta-output-tokens.md
deleted file mode 100644
index cbc8bc720..000000000
--- a/.sampo/changesets/cumulative-delta-output-tokens.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Streamed Anthropic generations no longer stack output tokens when a stream emits more than one `message_delta` (server tools can send several). Each delta's usage is cumulative, so the accumulator now keeps the latest total instead of adding every delta together.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 4672bcd96..72530f8c3 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.118 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.4
+
 ## 0.1.117 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 48d8ea70a..69586e3fa 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.117"
+version = "0.1.118"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 78146af1b..db223afe4 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.4 — 2026-10-22
+
+### Patch changes
+
+- [34ec4f8](https://github.com/posthog/posthog-python/commit/34ec4f828a45728c91e452e960aa0119a3052812) Streamed Anthropic generations no longer stack output tokens when a stream emits more than one `message_delta` (server tools can send several). Each delta's usage is cumulative, so the accumulator now keeps the latest total instead of adding every delta together. — Thanks @Harsh23Kashyap!
+
 ## 7.75.3 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index c05dfc087..0c240c3d9 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.3"
+VERSION = "7.75.4"
diff --git a/pyproject.toml b/pyproject.toml
index 91691ca73..38197c4f6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.3"
+version = "7.75.4"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index afdfd2f8e..31895cc52 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.117"
+version = "0.1.118"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.3"
+version = "7.75.4"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From e17a8bed922739c67bfbadd55d0c8ec9aab9ac2e Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 10:39:48 +0000
Subject: [PATCH 082/245] Update generated references

---
 .../posthog-python-references-7.75.4.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.4.json

diff --git a/references/posthog-python-references-7.75.4.json b/references/posthog-python-references-7.75.4.json
new file mode 100644
index 000000000..2cd75278e
--- /dev/null
+++ b/references/posthog-python-references-7.75.4.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.4",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 03f87f17f..2cd75278e 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.3",
+    "version": "7.75.4",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 18b39e895a45eed0e078c97848c03d0f066b3287 Mon Sep 17 00:00:00 2001
From: Harsh Kashyap <55448981+Harsh23Kashyap@users.noreply.github.com>
Date: Thu, 22 Oct 2026 19:56:56 +0530
Subject: [PATCH 083/245] fix: serialize non-finite floats as null in JSON
 payloads (#1081)

* fix: serialize non-finite floats as null in JSON payloads

Added a helper function to replace non-finite floats with None in JSON serialization.

* test: cover non-finite float serialization in batch payloads

* chore: refresh public API snapshot for DatetimeSerializer.encode
---
 posthog/request.py                 | 21 ++++++++++++++++
 posthog/test/test_request.py       | 40 ++++++++++++++++++++++++++++++
 references/public_api_snapshot.txt |  1 +
 3 files changed, 62 insertions(+)

diff --git a/posthog/request.py b/posthog/request.py
index 76df1fdc9..1c2456a77 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -1,5 +1,6 @@
 import json
 import logging
+import math
 import re
 import socket
 import time
@@ -479,9 +480,29 @@ class QuotaLimitError(APIError):
 RequestsConnectionError = requests.exceptions.ConnectionError
 
 
+def _replace_non_finite_floats(value: Any) -> Any:
+    """Recursively replace inf/nan floats with None.
+
+    json.dumps with the default allow_nan=True emits bare Infinity/NaN tokens,
+    which are not valid JSON and get rejected by strict-parsing ingestion (and
+    intermediaries). posthog-js avoids this because JSON.stringify converts
+    non-finite numbers to null; this mirrors that behavior.
+    """
+    if isinstance(value, float):
+        return value if math.isfinite(value) else None
+    if isinstance(value, dict):
+        return {key: _replace_non_finite_floats(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_replace_non_finite_floats(item) for item in value]
+    return value
+
+
 class DatetimeSerializer(json.JSONEncoder):
     def default(self, obj: Any):
         if isinstance(obj, (date, datetime)):
             return obj.isoformat()
 
         return json.JSONEncoder.default(self, obj)
+
+    def encode(self, o: Any) -> str:
+        return super().encode(_replace_non_finite_floats(o))
diff --git a/posthog/test/test_request.py b/posthog/test/test_request.py
index d4ad7c9da..455f24d82 100644
--- a/posthog/test/test_request.py
+++ b/posthog/test/test_request.py
@@ -776,3 +776,43 @@ def test_flags_does_not_retry_other_http_status_errors(self, status_code):
 
         self.assertEqual(cm.exception.status, status_code)
         self.assertEqual(mock_session.post.call_count, 1)
+
+
+def test_post_serializes_non_finite_floats_as_null():
+    mock_response = requests.Response()
+    mock_response.status_code = 200
+    mock_session = mock.MagicMock()
+    mock_session.post.return_value = mock_response
+
+    request_module.post(
+        TEST_API_KEY,
+        host="https://test.posthog.com",
+        path="/batch/",
+        session=mock_session,
+        batch=[
+            {
+                "event": "score_computed",
+                "distinct_id": "user-1",
+                "properties": {
+                    "score": float("inf"),
+                    "nested": [float("nan"), {"depth": float("-inf")}],
+                    "ok": 1.5,
+                },
+            }
+        ],
+    )
+
+    raw = mock_session.post.call_args.kwargs["data"]
+    # Bare Infinity/NaN tokens are not valid JSON; a strict parser must accept the body.
+    data = json.loads(
+        raw, parse_constant=lambda x: (_ for _ in ()).throw(ValueError(x))
+    )
+    props = data["batch"][0]["properties"]
+    assert props["score"] is None
+    assert props["nested"] == [None, {"depth": None}]
+    assert props["ok"] == 1.5
+
+
+def test_datetime_serializer_keeps_finite_values():
+    body = {"n": 1.5, "s": "x", "b": True, "i": 3, "none": None}
+    assert json.loads(json.dumps(body, cls=DatetimeSerializer)) == body
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index dc2bbe85f..f333489e3 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1827,6 +1827,7 @@ method posthog.metrics_capture.PostHogMetrics.reset() -> None
 method posthog.poller.Poller.run()
 method posthog.poller.Poller.stop()
 method posthog.request.DatetimeSerializer.default(obj: Any)
+method posthog.request.DatetimeSerializer.encode(o: Any) -> str
 method posthog.request.HTTPAdapterWithSocketOptions.init_poolmanager(*args, **kwargs)
 method posthog.tracing.span.Span.add_event(name: str, attributes: Optional[Mapping[str, Any]] = None, timestamp: Union[datetime, float, None] = None) -> Span
 method posthog.tracing.span.Span.end(end_time: Union[datetime, float, None] = None) -> None

From 635ac23d1baa695662a5707c1d6cfface7e18ce9 Mon Sep 17 00:00:00 2001
From: Eli Reisman <eli.r@posthog.com>
Date: Thu, 22 Oct 2026 08:39:02 -0700
Subject: [PATCH 084/245] test(mcp): drop get_tool checks that fastmcp 4.0.11
 invalidated (#1049)

fastmcp 4.0.11 resolves middleware-injected tools through the server's
tool lookup (PrefectHQ/fastmcp#5431), so get_tool() now returns them.
The two setup assertions that expected None fail on any fresh install.
The SDK behavior the tests check is unchanged and passes on 4.0.10 and
4.0.11.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

From b3fcec639aa9c49514344ba97b24492f03e87b86 Mon Sep 17 00:00:00 2001
From: Anna Garcia <11654201+turnipdabeets@users.noreply.github.com>
Date: Thu, 22 Oct 2026 13:58:01 -0400
Subject: [PATCH 085/245] fix: annotate client timeouts as float (#1106)

`timeout` and `feature_flags_request_timeout_seconds` were typed (or
inferred) as `int`, so type checkers rejected fractional values even
though they go straight to requests/httpx, which accept floats.

Fixes #1089

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .sampo/changesets/float-timeout-annotations.md |  5 +++++
 posthog/__init__.py                            |  2 +-
 posthog/_async_consumer.py                     |  2 +-
 posthog/_async_request.py                      |  8 ++++----
 posthog/async_client.py                        |  4 ++--
 posthog/capture_v1.py                          |  4 ++--
 posthog/client.py                              |  4 ++--
 posthog/consumer.py                            |  2 +-
 posthog/request.py                             | 14 +++++++-------
 references/public_api_snapshot.txt             | 16 ++++++++--------
 sdk_compliance_adapter/adapter.py              |  4 ++--
 typings/requests/__init__.pyi                  |  4 ++--
 12 files changed, 37 insertions(+), 32 deletions(-)
 create mode 100644 .sampo/changesets/float-timeout-annotations.md

diff --git a/.sampo/changesets/float-timeout-annotations.md b/.sampo/changesets/float-timeout-annotations.md
new file mode 100644
index 000000000..fd4222710
--- /dev/null
+++ b/.sampo/changesets/float-timeout-annotations.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Annotate `timeout` and `feature_flags_request_timeout_seconds` as `float` on `Client`, `AsyncClient`, `Consumer` and the request helpers, so type checkers accept fractional timeouts such as `timeout=2.5`. The values were already passed straight to `requests` and `httpx`, which take floats, so runtime behaviour is unchanged.
diff --git a/posthog/__init__.py b/posthog/__init__.py
index 66fb9ea19..2e870403c 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -408,7 +408,7 @@ def get_tags() -> Dict[str, Any]:
 poll_interval = 30  # type: int
 disable_geoip = True  # type: bool
 is_server = True  # type: bool
-feature_flags_request_timeout_seconds = 3  # type: int
+feature_flags_request_timeout_seconds = 3  # type: float
 feature_flags_request_max_retries = 1  # type: int
 super_properties = None  # type: Optional[Dict]
 metrics = None  # type: Optional[Dict]
diff --git a/posthog/_async_consumer.py b/posthog/_async_consumer.py
index 04eeb082b..5bdfd33f1 100644
--- a/posthog/_async_consumer.py
+++ b/posthog/_async_consumer.py
@@ -70,7 +70,7 @@ def __init__(
         flush_interval: float,
         gzip: bool,
         retries: int,
-        timeout: int,
+        timeout: float,
         historical_migration: bool,
         capture_mode: CaptureMode,
         capture_compression: CaptureCompression,
diff --git a/posthog/_async_request.py b/posthog/_async_request.py
index ae750de9a..00120971a 100644
--- a/posthog/_async_request.py
+++ b/posthog/_async_request.py
@@ -132,7 +132,7 @@ async def async_flags(
     api_key: str,
     host: Optional[str],
     *,
-    timeout: int,
+    timeout: float,
     max_retries: int,
     client: Optional[Any] = None,
     **request_data: Any,
@@ -175,7 +175,7 @@ async def async_remote_config(
     host: Optional[str],
     key: str,
     *,
-    timeout: int,
+    timeout: float,
     client: Optional[Any] = None,
 ) -> Any:
     """Fetch and decrypt one remote-config payload."""
@@ -203,7 +203,7 @@ async def async_batch_post(
     batch: list[dict[str, Any]],
     path: str,
     gzip: bool = False,
-    timeout: int = 15,
+    timeout: float = 15,
     historical_migration: bool = False,
     client: Optional[Any] = None,
 ) -> None:
@@ -260,7 +260,7 @@ async def async_send_v1_batch(
     batch: list[dict[str, Any]],
     *,
     compression: CaptureCompression,
-    timeout: int,
+    timeout: float,
     max_retries: int,
     historical_migration: bool,
 ) -> None:
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 3f429e81a..186bff727 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -106,7 +106,7 @@ def __init__(
         flush_interval: float = 5.0,
         gzip: bool = False,
         max_retries: int = 3,
-        timeout: int = 15,
+        timeout: float = 15,
         thread: int = 1,
         disabled: bool = False,
         disable_geoip: bool = True,
@@ -127,7 +127,7 @@ def __init__(
         capture_trace_context: bool = False,
         secret_key: Optional[str] = None,
         personal_api_key: Optional[str] = None,
-        feature_flags_request_timeout_seconds: int = 3,
+        feature_flags_request_timeout_seconds: float = 3,
         feature_flags_request_max_retries: int = 1,
     ) -> None:
         if flush_at <= 0:
diff --git a/posthog/capture_v1.py b/posthog/capture_v1.py
index 478175484..1ae31ce71 100644
--- a/posthog/capture_v1.py
+++ b/posthog/capture_v1.py
@@ -347,7 +347,7 @@ def _post_v1(
     attempt: int,
     request_id: str,
     compression: CaptureCompression = CaptureCompression.NONE,
-    timeout: int = 15,
+    timeout: float = 15,
     sdk_info: str = USER_AGENT,
     session: Optional["requests.Session"] = None,
 ) -> "requests.Response":
@@ -468,7 +468,7 @@ def _send_v1_batch(
     batch: list[dict],
     *,
     compression: CaptureCompression = CaptureCompression.NONE,
-    timeout: int = 15,
+    timeout: float = 15,
     max_retries: int = 3,
     historical_migration: bool = False,
     sdk_info: str = USER_AGENT,
diff --git a/posthog/client.py b/posthog/client.py
index 27fee5428..5aa552dc3 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -682,7 +682,7 @@ def __init__(
         gzip=False,
         max_retries=3,
         sync_mode=False,
-        timeout=15,
+        timeout: float = 15,
         thread=1,
         poll_interval=30,
         personal_api_key=None,
@@ -690,7 +690,7 @@ def __init__(
         disable_geoip=True,
         is_server=True,
         historical_migration=False,
-        feature_flags_request_timeout_seconds=3,
+        feature_flags_request_timeout_seconds: float = 3,
         feature_flags_request_max_retries=1,
         super_properties=None,
         enable_exception_autocapture=False,
diff --git a/posthog/consumer.py b/posthog/consumer.py
index c604b9756..0190dcf01 100644
--- a/posthog/consumer.py
+++ b/posthog/consumer.py
@@ -111,7 +111,7 @@ def __init__(
         flush_interval=5.0,
         gzip=False,
         retries=10,
-        timeout=15,
+        timeout: float = 15,
         historical_migration=False,
         endpoint=EVENTS_ENDPOINT,
         max_msg_size=MAX_MSG_SIZE,
diff --git a/posthog/request.py b/posthog/request.py
index 1c2456a77..9b7b1b1b2 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -218,7 +218,7 @@ def post(
     host: Optional[str] = None,
     path: Optional[str] = None,
     gzip: bool = False,
-    timeout: int = 15,
+    timeout: float = 15,
     session: Optional[requests.Session] = None,
     **kwargs,
 ) -> requests.Response:
@@ -316,7 +316,7 @@ def flags(
     api_key: str,
     host: Optional[str] = None,
     gzip: bool = False,
-    timeout: int = 15,
+    timeout: float = 15,
     max_retries: int = 1,
     **kwargs,
 ) -> Any:
@@ -358,7 +358,7 @@ def remote_config(
     project_api_key: str,
     host: Optional[str] = None,
     key: str = "",
-    timeout: int = 15,
+    timeout: float = 15,
 ) -> Any:
     """Get remote config flag value from remote_config API endpoint"""
     return _remote_config(personal_api_key, project_api_key, host, key, timeout)
@@ -369,7 +369,7 @@ def _remote_config(
     project_api_key: str,
     host: Optional[str] = None,
     key: str = "",
-    timeout: int = 15,
+    timeout: float = 15,
     *,
     _user_agent: str = USER_AGENT,
 ) -> Any:
@@ -391,7 +391,7 @@ def batch_post(
     api_key: str,
     host: Optional[str] = None,
     gzip: bool = False,
-    timeout: int = 15,
+    timeout: float = 15,
     path: str = EVENTS_ENDPOINT,
     **kwargs,
 ) -> requests.Response:
@@ -406,7 +406,7 @@ def get(
     api_key: str,
     url: str,
     host: Optional[str] = None,
-    timeout: Optional[int] = None,
+    timeout: Optional[float] = None,
     etag: Optional[str] = None,
 ) -> GetResponse:
     """
@@ -423,7 +423,7 @@ def _get(
     api_key: str,
     url: str,
     host: Optional[str] = None,
-    timeout: Optional[int] = None,
+    timeout: Optional[float] = None,
     etag: Optional[str] = None,
     *,
     _user_agent: str = USER_AGENT,
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index f333489e3..a7d09a3ff 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1271,14 +1271,14 @@ class posthog.ai.types.TokenUsage
 class posthog.ai.types.ToolInProgress 
 class posthog.args.OptionalCaptureArgs 
 class posthog.args.OptionalSetArgs 
-class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: int = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: int = 3, feature_flags_request_max_retries: int = 1)
+class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1)
 class posthog.async_client.AsyncPosthog 
 class posthog.bucketed_rate_limiter.BucketedRateLimiter(bucket_size: Number, refill_rate: Number, refill_interval_seconds: Number, on_bucket_rate_limited: Optional[Callable[[Hashable], None]] = None, clock: Callable[[], float] = time.monotonic)
 class posthog.capture_compression.CaptureCompression 
 class posthog.capture_mode.CaptureMode 
 class posthog.capture_v1.CaptureV1Error(status: int | str, message: str, *, retry_after: Optional[float] = None, request_id: Optional[str] = None, attempts: Optional[int] = None, retry_exhausted: Optional[list[str]] = None, drops: Optional[list[tuple[str, Optional[str]]]] = None)
-class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout=15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds=3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None)
-class posthog.consumer.Consumer(queue, api_key, flush_at=100, host=None, on_error=None, flush_interval=5.0, gzip=False, retries=10, timeout=15, historical_migration=False, endpoint=EVENTS_ENDPOINT, max_msg_size=MAX_MSG_SIZE, capture_mode=CaptureMode.V0, capture_compression=CaptureCompression.NONE)
+class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None)
+class posthog.consumer.Consumer(queue, api_key, flush_at=100, host=None, on_error=None, flush_interval=5.0, gzip=False, retries=10, timeout: float = 15, historical_migration=False, endpoint=EVENTS_ENDPOINT, max_msg_size=MAX_MSG_SIZE, capture_mode=CaptureMode.V0, capture_compression=CaptureCompression.NONE)
 class posthog.contexts.ContextScope(parent=None, fresh: bool = False, capture_exceptions: bool = True, client: Optional[Client] = None)
 class posthog.exception_capture.ExceptionCapture(client: Client, rate_limiting_enabled=False, bucket_size=DEFAULT_BUCKET_SIZE, refill_rate=DEFAULT_REFILL_RATE, refill_interval_seconds=DEFAULT_REFILL_INTERVAL_SECONDS)
 class posthog.exception_utils.AnnotatedValue(value, metadata)
@@ -1517,15 +1517,15 @@ function posthog.mcp.session_token.encode_session_id(payload: SessionTokenPayloa
 function posthog.mcp.session_token.read_mcp_session_header(headers: Any) -> Optional[str]
 function posthog.mcp.tools.get_more_tools_result() -> Dict[str, Any]
 function posthog.new_context(fresh: bool = False, capture_exceptions: Optional[bool] = None, client: Optional[Client] = None)
-function posthog.request.batch_post(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, path: str = EVENTS_ENDPOINT, **kwargs) -> requests.Response
+function posthog.request.batch_post(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: float = 15, path: str = EVENTS_ENDPOINT, **kwargs) -> requests.Response
 function posthog.request.determine_server_host(host: Optional[str]) -> str
 function posthog.request.disable_connection_reuse() -> None
 function posthog.request.enable_keep_alive() -> None
-function posthog.request.flags(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, max_retries: int = 1, **kwargs) -> Any
-function posthog.request.get(api_key: str, url: str, host: Optional[str] = None, timeout: Optional[int] = None, etag: Optional[str] = None) -> GetResponse
+function posthog.request.flags(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: float = 15, max_retries: int = 1, **kwargs) -> Any
+function posthog.request.get(api_key: str, url: str, host: Optional[str] = None, timeout: Optional[float] = None, etag: Optional[str] = None) -> GetResponse
 function posthog.request.normalize_host(host: Optional[str]) -> str
-function posthog.request.post(api_key: str, host: Optional[str] = None, path: Optional[str] = None, gzip: bool = False, timeout: int = 15, session: Optional[requests.Session] = None, **kwargs) -> requests.Response
-function posthog.request.remote_config(personal_api_key: str, project_api_key: str, host: Optional[str] = None, key: str = '', timeout: int = 15) -> Any
+function posthog.request.post(api_key: str, host: Optional[str] = None, path: Optional[str] = None, gzip: bool = False, timeout: float = 15, session: Optional[requests.Session] = None, **kwargs) -> requests.Response
+function posthog.request.remote_config(personal_api_key: str, project_api_key: str, host: Optional[str] = None, key: str = '', timeout: float = 15) -> Any
 function posthog.request.reset_sessions() -> None
 function posthog.request.set_socket_options(socket_options: Optional[SocketOptions]) -> None
 function posthog.scoped(fresh=False, capture_exceptions: Optional[bool] = None)
diff --git a/sdk_compliance_adapter/adapter.py b/sdk_compliance_adapter/adapter.py
index 0d803ae52..8ff4ffff7 100644
--- a/sdk_compliance_adapter/adapter.py
+++ b/sdk_compliance_adapter/adapter.py
@@ -204,7 +204,7 @@ def patched_batch_post(
     api_key: str,
     host: Optional[str] = None,
     gzip: bool = False,
-    timeout: int = 15,
+    timeout: float = 15,
     path: str = EVENTS_ENDPOINT,
     **kwargs,
 ):
@@ -236,7 +236,7 @@ def patched_post_v1(
     attempt: int,
     request_id: str,
     compression: CaptureCompression = CaptureCompression.NONE,
-    timeout: int = 15,
+    timeout: float = 15,
     sdk_info: str = USER_AGENT,
     session: Any = None,
 ):
diff --git a/typings/requests/__init__.pyi b/typings/requests/__init__.pyi
index 9e7892beb..9e92acd35 100644
--- a/typings/requests/__init__.pyi
+++ b/typings/requests/__init__.pyi
@@ -34,7 +34,7 @@ class Session:
         *,
         data: str | bytes,
         headers: dict[str, str],
-        timeout: int,
+        timeout: float,
         stream: bool = ...,
     ) -> Response: ...
     def get(
@@ -42,5 +42,5 @@ class Session:
         url: str,
         *,
         headers: dict[str, str],
-        timeout: int | None = ...,
+        timeout: float | None = ...,
     ) -> Response: ...

From a7742232151193989e722907d9c025045bda2631 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 18:06:42 +0000
Subject: [PATCH 086/245] chore: Release v7.75.5 [skip ci]

---
 .sampo/changesets/float-timeout-annotations.md | 5 -----
 openfeature-provider/CHANGELOG.md              | 6 ++++++
 openfeature-provider/pyproject.toml            | 2 +-
 posthog/CHANGELOG.md                           | 6 ++++++
 posthog/version.py                             | 2 +-
 pyproject.toml                                 | 2 +-
 uv.lock                                        | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/float-timeout-annotations.md

diff --git a/.sampo/changesets/float-timeout-annotations.md b/.sampo/changesets/float-timeout-annotations.md
deleted file mode 100644
index fd4222710..000000000
--- a/.sampo/changesets/float-timeout-annotations.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Annotate `timeout` and `feature_flags_request_timeout_seconds` as `float` on `Client`, `AsyncClient`, `Consumer` and the request helpers, so type checkers accept fractional timeouts such as `timeout=2.5`. The values were already passed straight to `requests` and `httpx`, which take floats, so runtime behaviour is unchanged.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 72530f8c3..0d7e4f0b2 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.119 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.5
+
 ## 0.1.118 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 69586e3fa..832cc7638 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.118"
+version = "0.1.119"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index db223afe4..7953462ba 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.5 — 2026-10-22
+
+### Patch changes
+
+- [b3fcec6](https://github.com/posthog/posthog-python/commit/b3fcec639aa9c49514344ba97b24492f03e87b86) Annotate `timeout` and `feature_flags_request_timeout_seconds` as `float` on `Client`, `AsyncClient`, `Consumer` and the request helpers, so type checkers accept fractional timeouts such as `timeout=2.5`. The values were already passed straight to `requests` and `httpx`, which take floats, so runtime behaviour is unchanged. — Thanks @turnipdabeets!
+
 ## 7.75.4 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 0c240c3d9..63ec533cb 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.4"
+VERSION = "7.75.5"
diff --git a/pyproject.toml b/pyproject.toml
index 38197c4f6..298dae164 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.5"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 31895cc52..18afee07c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.118"
+version = "0.1.119"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.5"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 8c2d8f625f7c40cfc3b87f47dc65bc15c4721d7b Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 18:06:47 +0000
Subject: [PATCH 087/245] Update generated references

---
 .../posthog-python-references-7.75.5.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    6 +-
 2 files changed, 3551 insertions(+), 3 deletions(-)
 create mode 100644 references/posthog-python-references-7.75.5.json

diff --git a/references/posthog-python-references-7.75.5.json b/references/posthog-python-references-7.75.5.json
new file mode 100644
index 000000000..342f66487
--- /dev/null
+++ b/references/posthog-python-references-7.75.5.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.5",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 2cd75278e..342f66487 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.4",
+    "version": "7.75.5",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -437,7 +437,7 @@
               "name": "timeout",
               "description": "HTTP request timeout in seconds for event uploads.",
               "isOptional": false,
-              "type": "int"
+              "type": "float"
             },
             {
               "name": "thread",
@@ -485,7 +485,7 @@
               "name": "feature_flags_request_timeout_seconds",
               "description": "Timeout in seconds for feature         flag and remote config requests.",
               "isOptional": false,
-              "type": "int"
+              "type": "float"
             },
             {
               "name": "feature_flags_request_max_retries",

From a95331f171a33ca0674833a5aada371cc6446bc9 Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Thu, 22 Oct 2026 14:08:37 -0400
Subject: [PATCH 088/245] fix(flags): retain tracking metadata in local
 evaluation snapshots (#1041)

---
 .../local-snapshot-tracking-metadata.md       |  5 ++
 posthog/client.py                             | 46 +++++-----
 .../test_feature_flag_called_minimization.py  | 86 +++++++++++++++++++
 .../test/test_property_matching_version.py    |  2 +-
 4 files changed, 118 insertions(+), 21 deletions(-)
 create mode 100644 .sampo/changesets/local-snapshot-tracking-metadata.md

diff --git a/.sampo/changesets/local-snapshot-tracking-metadata.md b/.sampo/changesets/local-snapshot-tracking-metadata.md
new file mode 100644
index 000000000..82b003845
--- /dev/null
+++ b/.sampo/changesets/local-snapshot-tracking-metadata.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Retain the minimal-event gate and experiment metadata from the local definitions used by `evaluate_flags()`, including first-use loading and definition refreshes during evaluation.
diff --git a/posthog/client.py b/posthog/client.py
index 5aa552dc3..bff6def5d 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -3272,6 +3272,7 @@ def _local_evaluation_snapshot(self) -> _LocalEvaluationSnapshot:
                 "group_type_mapping": self.group_type_mapping or {},
                 "cohorts": self.cohorts or {},
                 "property_matching_version": self._property_matching_version,
+                "minimal_flag_called_events": self._minimal_flag_called_events,
                 "flag_definition_version": self.flag_definition_version,
             }
 
@@ -4472,7 +4473,7 @@ def get_all_flags_and_payloads(
         local_person_properties = self._person_properties_for_local_evaluation(
             distinct_id, person_properties
         )
-        response, fallback_to_flags = self._get_all_flags_and_payloads_locally(
+        response, fallback_to_flags, _ = self._get_all_flags_and_payloads_locally(
             distinct_id,
             groups=groups,
             person_properties=local_person_properties,
@@ -4609,26 +4610,27 @@ def evaluate_flags(
         errors_while_computing = False
         quota_limited = False
         locally_evaluated_keys: set[str] = set()
-        # Source the gate the same way as has_experiment below; see
-        # _capture_feature_flag_called_if_needed for why. Defaults to the poller's
-        # current state; a successful remote fallback overwrites it with that
-        # response's own field below.
-        minimal_flag_called_events = self._minimal_flag_called_events
-
         # Try local evaluation first when the poller has loaded definitions.
         local_person_properties = self._person_properties_for_local_evaluation(
             distinct_id, person_properties
         )
-        local_result, fallback_to_server = self._get_all_flags_and_payloads_locally(
-            distinct_id,
-            groups=dict(groups),
-            person_properties=local_person_properties,
-            group_properties=group_properties,
-            flag_keys_to_evaluate=flag_keys,
-            device_id=device_id,
+        local_result, fallback_to_server, definition_snapshot = (
+            self._get_all_flags_and_payloads_locally(
+                distinct_id,
+                groups=dict(groups),
+                person_properties=local_person_properties,
+                group_properties=group_properties,
+                flag_keys_to_evaluate=flag_keys,
+                device_id=device_id,
+            )
         )
 
-        feature_flags_by_key: Dict[str, Any] = self.feature_flags_by_key or {}
+        # Pin local tracking metadata to the definitions used for these values.
+        # A successful remote fallback below supplies its own gate instead.
+        minimal_flag_called_events = definition_snapshot.get(
+            "minimal_flag_called_events", False
+        )
+        feature_flags_by_key = definition_snapshot["flags_by_key"]
         local_flags = local_result.get("featureFlags") or {}
         local_payloads = local_result.get("featureFlagPayloads") or {}
         if requested_keys and not requested_keys.issubset(local_flags):
@@ -4752,7 +4754,7 @@ def _get_all_flags_and_payloads_locally(
         warn_on_unknown_groups=False,
         flag_keys_to_evaluate: Optional[list[str]] = None,
         device_id: Optional[str] = None,
-    ) -> tuple[FlagsAndPayloads, bool]:
+    ) -> tuple[FlagsAndPayloads, bool, _LocalEvaluationSnapshot]:
         person_properties = person_properties or {}
         group_properties = group_properties or {}
 
@@ -4803,10 +4805,14 @@ def _get_all_flags_and_payloads_locally(
         else:
             fallback_to_flags = True
 
-        return {
-            "featureFlags": flags,
-            "featureFlagPayloads": payloads,
-        }, fallback_to_flags
+        return (
+            {
+                "featureFlags": flags,
+                "featureFlagPayloads": payloads,
+            },
+            fallback_to_flags,
+            snapshot,
+        )
 
     def _initialize_flag_cache(self, cache_url):
         """Initialize feature flag cache for graceful degradation during service outages.
diff --git a/posthog/test/test_feature_flag_called_minimization.py b/posthog/test/test_feature_flag_called_minimization.py
index c32b4ea27..32310beca 100644
--- a/posthog/test/test_feature_flag_called_minimization.py
+++ b/posthog/test/test_feature_flag_called_minimization.py
@@ -391,6 +391,92 @@ def _snapshot_response(self, has_experiment, gate):
             response["minimalFlagCalledEvents"] = gate
         return response
 
+    @parameterized.expand([("api",), ("cache",)])
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_lazy_local_snapshot_retains_loaded_minimal_gate(
+        self, source, patch_get, patch_flags
+    ):
+        definitions = {
+            "flags": [_local_flag_definition(False)],
+            "group_type_mapping": {},
+            "cohorts": {},
+            "minimal_flag_called_events": True,
+        }
+        patch_get.return_value = GetResponse(data=definitions, etag='"etag-1"')
+        provider = None
+        if source == "cache":
+            provider = mock.Mock()
+            provider.should_fetch_flag_definitions.return_value = False
+            provider.get_flag_definitions.return_value = definitions
+            provider.shutdown.return_value = None
+        client, captured = self._make_client(
+            secret_key="personal-key",
+            enable_local_evaluation=False,
+            flag_definition_cache_provider=provider,
+        )
+        self.addCleanup(client.shutdown)
+
+        snapshot = client.evaluate_flags("user-1")
+        self.assertTrue(snapshot.get_flag("person-flag"))
+
+        properties = self._flag_called_properties(captured)
+        self.assertLessEqual(set(properties), _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES)
+        self.assertNotIn("app_version", properties)
+        self.assertIs(properties["locally_evaluated"], True)
+        patch_flags.assert_not_called()
+        if source == "cache":
+            patch_get.assert_not_called()
+        else:
+            patch_get.assert_called_once()
+
+    @parameterized.expand([("gate_on", True), ("gate_off", False)])
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_local_snapshot_retains_metadata_when_definitions_refresh_during_evaluation(
+        self, _name, gate, patch_get, patch_flags
+    ):
+        definitions = {
+            "flags": [_local_flag_definition(False)],
+            "group_type_mapping": {},
+            "cohorts": {},
+            "minimal_flag_called_events": gate,
+        }
+        patch_get.return_value = GetResponse(data=definitions, etag='"etag-1"')
+        client, captured = self._make_client(
+            secret_key="personal-key", enable_local_evaluation=False
+        )
+        self.addCleanup(client.shutdown)
+        original_compute = client._compute_flag_locally
+
+        def evaluate_then_refresh(*args, **kwargs):
+            value = original_compute(*args, **kwargs)
+            # A poll publishes new tracking metadata while this evaluation is
+            # still using the previous definition snapshot.
+            client._update_flag_state(
+                {
+                    **definitions,
+                    "flags": [_local_flag_definition(True)],
+                    "minimal_flag_called_events": not gate,
+                }
+            )
+            return value
+
+        with mock.patch.object(
+            client, "_compute_flag_locally", side_effect=evaluate_then_refresh
+        ):
+            snapshot = client.evaluate_flags("user-1")
+        self.assertTrue(snapshot.get_flag("person-flag"))
+
+        properties = self._flag_called_properties(captured)
+        self.assertIs(properties["$feature_flag_has_experiment"], False)
+        if gate:
+            self.assertLessEqual(set(properties), _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES)
+            self.assertNotIn("app_version", properties)
+        else:
+            self.assertEqual(properties["app_version"], "1.2.3")
+        patch_flags.assert_not_called()
+
     @mock.patch("posthog.client.flags")
     def test_gated_non_experiment_flag_sends_exactly_the_allowlist(self, patch_flags):
         patch_flags.return_value = self._snapshot_response(
diff --git a/posthog/test/test_property_matching_version.py b/posthog/test/test_property_matching_version.py
index 640efacb5..f6f1f8774 100644
--- a/posthog/test/test_property_matching_version.py
+++ b/posthog/test/test_property_matching_version.py
@@ -238,7 +238,7 @@ def reload_during_evaluation(*args, **kwargs):
         "posthog.client.match_feature_flag_properties",
         side_effect=reload_during_evaluation,
     ):
-        result, fallback = client._get_all_flags_and_payloads_locally(
+        result, fallback, _ = client._get_all_flags_and_payloads_locally(
             "user",
             groups={"company": "company-id"},
             person_properties={"value": "banana"},

From a5909dc4d507e36a7cb08b21a685ca8b06d7f7de Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 18:11:33 +0000
Subject: [PATCH 089/245] chore: Release v7.75.6 [skip ci]

---
 .sampo/changesets/local-snapshot-tracking-metadata.md | 5 -----
 openfeature-provider/CHANGELOG.md                     | 6 ++++++
 openfeature-provider/pyproject.toml                   | 2 +-
 posthog/CHANGELOG.md                                  | 6 ++++++
 posthog/version.py                                    | 2 +-
 pyproject.toml                                        | 2 +-
 uv.lock                                               | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/local-snapshot-tracking-metadata.md

diff --git a/.sampo/changesets/local-snapshot-tracking-metadata.md b/.sampo/changesets/local-snapshot-tracking-metadata.md
deleted file mode 100644
index 82b003845..000000000
--- a/.sampo/changesets/local-snapshot-tracking-metadata.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Retain the minimal-event gate and experiment metadata from the local definitions used by `evaluate_flags()`, including first-use loading and definition refreshes during evaluation.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 0d7e4f0b2..2d706fe7c 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.120 — 2026-10-22
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.6
+
 ## 0.1.119 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 832cc7638..402ff9796 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.119"
+version = "0.1.120"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 7953462ba..0219635ea 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.6 — 2026-10-22
+
+### Patch changes
+
+- [a95331f](https://github.com/posthog/posthog-python/commit/a95331f171a33ca0674833a5aada371cc6446bc9) Retain the minimal-event gate and experiment metadata from the local definitions used by `evaluate_flags()`, including first-use loading and definition refreshes during evaluation. — Thanks @dustinbyrne!
+
 ## 7.75.5 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 63ec533cb..4121f4176 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.5"
+VERSION = "7.75.6"
diff --git a/pyproject.toml b/pyproject.toml
index 298dae164..782d41551 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.5"
+version = "7.75.6"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 18afee07c..81524ec2c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2662,7 +2662,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.119"
+version = "0.1.120"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3021,7 +3021,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.5"
+version = "7.75.6"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 4b280fcace78f10af24ef47bac1fa7ff7d9b56c9 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 22 Oct 2026 18:11:39 +0000
Subject: [PATCH 090/245] Update generated references

---
 .../posthog-python-references-7.75.6.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.6.json

diff --git a/references/posthog-python-references-7.75.6.json b/references/posthog-python-references-7.75.6.json
new file mode 100644
index 000000000..ecbda11e3
--- /dev/null
+++ b/references/posthog-python-references-7.75.6.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.6",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 342f66487..ecbda11e3 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.5",
+    "version": "7.75.6",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 7651b10da2d3594de0dbd808883c5a7f2e5398e8 Mon Sep 17 00:00:00 2001
From: Georges-Antoine Assi <3247106+gantoine@users.noreply.github.com>
Date: Thu, 22 Oct 2026 15:05:41 -0400
Subject: [PATCH 091/245] chore(deps): bump uv to 0.13.4 and certifi to
 2026.10.19 (#1104)

Bump uv to 0.13.4 and certifi to 2026.10.19

Eight eMudhra intermediate CA private keys were broken, so anyone
holding them can impersonate TLS servers to clients that still trust
emSign ECC Root CA - G3. uv 0.13.4 and certifi 2026.10.19 are the first
releases whose bundled CA store drops that root, and the versions pinned
here still trust it. See the Python.org notice.
https://discuss.python.org/t/information-for-python-users-regarding-emudhra-emsign-ca-certificate-security-incident/109576


Claude-Session: https://claude.ai/code/session_01T4ck1tYoQv3mzBTXH17asD

Co-authored-by: Claude <noreply@anthropic.com>
---
 .github/actions/setup-python-dev/action.yml   |  2 +-
 .github/workflows/ci.yml                      | 12 ++--
 .github/workflows/posthog-upgrade.yml         |  2 +-
 .github/workflows/release.yml                 |  6 +-
 examples/example-ai-anthropic/uv.lock         | 18 ++++--
 examples/example-ai-anthropic/uv.toml         |  2 +
 examples/example-ai-autogen/uv.lock           | 18 ++++--
 examples/example-ai-autogen/uv.toml           |  2 +
 examples/example-ai-aws-bedrock/uv.lock       | 18 ++++--
 examples/example-ai-aws-bedrock/uv.toml       |  2 +
 examples/example-ai-azure-openai/uv.lock      | 18 ++++--
 examples/example-ai-azure-openai/uv.toml      |  2 +
 examples/example-ai-cerebras/uv.lock          | 18 ++++--
 examples/example-ai-cerebras/uv.toml          |  2 +
 .../example-ai-cloudflare-ai-gateway/uv.lock  | 18 ++++--
 .../example-ai-cloudflare-ai-gateway/uv.toml  |  2 +
 examples/example-ai-cohere/uv.lock            | 18 ++++--
 examples/example-ai-cohere/uv.toml            |  2 +
 examples/example-ai-crewai/uv.lock            | 56 ++++++++++---------
 examples/example-ai-crewai/uv.toml            |  2 +
 examples/example-ai-dedalus/uv.lock           | 18 ++++--
 examples/example-ai-dedalus/uv.toml           |  2 +
 examples/example-ai-deepseek/uv.lock          | 18 ++++--
 examples/example-ai-deepseek/uv.toml          |  2 +
 examples/example-ai-dspy/uv.lock              | 11 ++--
 examples/example-ai-dspy/uv.toml              |  2 +
 examples/example-ai-fireworks-ai/uv.lock      | 18 ++++--
 examples/example-ai-fireworks-ai/uv.toml      |  2 +
 examples/example-ai-gemini/uv.lock            | 18 ++++--
 examples/example-ai-gemini/uv.toml            |  2 +
 examples/example-ai-groq/uv.lock              | 18 ++++--
 examples/example-ai-groq/uv.toml              |  2 +
 examples/example-ai-helicone/uv.lock          | 18 ++++--
 examples/example-ai-helicone/uv.toml          |  2 +
 examples/example-ai-hugging-face/uv.lock      | 18 ++++--
 examples/example-ai-hugging-face/uv.toml      |  2 +
 examples/example-ai-instructor/uv.lock        | 16 ++++--
 examples/example-ai-instructor/uv.toml        |  2 +
 examples/example-ai-langchain/uv.lock         | 18 ++++--
 examples/example-ai-langchain/uv.toml         |  2 +
 examples/example-ai-langgraph/uv.lock         | 18 ++++--
 examples/example-ai-langgraph/uv.toml         |  2 +
 examples/example-ai-litellm/uv.lock           | 11 ++--
 examples/example-ai-litellm/uv.toml           |  2 +
 examples/example-ai-llamaindex/uv.lock        | 16 ++++--
 examples/example-ai-llamaindex/uv.toml        |  2 +
 examples/example-ai-mirascope/uv.lock         | 18 ++++--
 examples/example-ai-mirascope/uv.toml         |  2 +
 examples/example-ai-mistral/uv.lock           | 18 ++++--
 examples/example-ai-mistral/uv.toml           |  2 +
 examples/example-ai-ollama/uv.lock            | 18 ++++--
 examples/example-ai-ollama/uv.toml            |  2 +
 examples/example-ai-openai-agents/uv.lock     | 11 ++--
 examples/example-ai-openai-agents/uv.toml     |  2 +
 examples/example-ai-openai/uv.lock            | 18 ++++--
 examples/example-ai-openai/uv.toml            |  2 +
 examples/example-ai-openrouter/uv.lock        | 18 ++++--
 examples/example-ai-openrouter/uv.toml        |  2 +
 examples/example-ai-perplexity/uv.lock        | 18 ++++--
 examples/example-ai-perplexity/uv.toml        |  2 +
 examples/example-ai-portkey/uv.lock           | 18 ++++--
 examples/example-ai-portkey/uv.toml           |  2 +
 examples/example-ai-pydantic-ai/uv.lock       | 16 ++++--
 examples/example-ai-pydantic-ai/uv.toml       |  2 +
 examples/example-ai-semantic-kernel/uv.lock   | 16 ++++--
 examples/example-ai-semantic-kernel/uv.toml   |  2 +
 examples/example-ai-smolagents/uv.lock        | 18 ++++--
 examples/example-ai-smolagents/uv.toml        |  2 +
 examples/example-ai-together-ai/uv.lock       | 18 ++++--
 examples/example-ai-together-ai/uv.toml       |  2 +
 examples/example-ai-vercel-ai-gateway/uv.lock | 18 ++++--
 examples/example-ai-vercel-ai-gateway/uv.toml |  2 +
 examples/example-ai-xai/uv.lock               | 18 ++++--
 examples/example-ai-xai/uv.toml               |  2 +
 integration_tests/django5/pyproject.toml      |  2 +
 integration_tests/django5/uv.lock             | 16 ++++--
 .../fastapi-async-client/pyproject.toml       |  2 +
 playgrounds/fastapi-async-client/uv.lock      | 18 ++++--
 pyproject.toml                                |  2 +
 uv.lock                                       | 11 ++--
 80 files changed, 564 insertions(+), 218 deletions(-)

diff --git a/.github/actions/setup-python-dev/action.yml b/.github/actions/setup-python-dev/action.yml
index 863d5abef..347ebeafd 100644
--- a/.github/actions/setup-python-dev/action.yml
+++ b/.github/actions/setup-python-dev/action.yml
@@ -18,7 +18,7 @@ runs:
         - name: Install uv
           uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
           with:
-              version: "0.11.32"
+              version: "0.13.4"
               enable-cache: true
 
         - name: Install dev dependencies
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f92d5194d..92334514d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -111,7 +111,7 @@ jobs:
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             - name: Build and verify distributions
@@ -139,7 +139,7 @@ jobs:
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             - name: Install test dependencies
@@ -178,7 +178,7 @@ jobs:
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             - name: Install test dependencies
@@ -244,7 +244,7 @@ jobs:
               if: steps.changes.outputs.changed == 'true'
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             - name: Check utils CRAP score
@@ -325,7 +325,7 @@ jobs:
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             # openfeature-provider-posthog is a uv workspace member (declared in
@@ -380,7 +380,7 @@ jobs:
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
               with:
-                  version: "0.11.32"
+                  version: "0.13.4"
                   enable-cache: true
 
             - name: Install Django 5 test project dependencies
diff --git a/.github/workflows/posthog-upgrade.yml b/.github/workflows/posthog-upgrade.yml
index 585f2958b..0c1f8126f 100644
--- a/.github/workflows/posthog-upgrade.yml
+++ b/.github/workflows/posthog-upgrade.yml
@@ -44,7 +44,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
-          version: "0.12.21"
+          version: "0.13.4"
 
       - name: Install new package version in main repo
         shell: bash
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2de109583..e8afa85bc 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -103,7 +103,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
-          version: "0.11.32"
+          version: "0.13.4"
           enable-cache: true
 
       - name: Install Rust
@@ -308,7 +308,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
-          version: "0.11.32"
+          version: "0.13.4"
           enable-cache: true
 
       - name: Install dependencies
@@ -475,7 +475,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
-          version: "0.11.32"
+          version: "0.13.4"
           enable-cache: true
 
       - name: Install Rust
diff --git a/examples/example-ai-anthropic/uv.lock b/examples/example-ai-anthropic/uv.lock
index 88660457b..2162e2894 100644
--- a/examples/example-ai-anthropic/uv.lock
+++ b/examples/example-ai-anthropic/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -59,11 +62,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -523,7 +526,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.62.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -542,12 +545,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -569,6 +576,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-anthropic/uv.toml b/examples/example-ai-anthropic/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-anthropic/uv.toml
+++ b/examples/example-ai-anthropic/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-autogen/uv.lock b/examples/example-ai-autogen/uv.lock
index 639ed6ea7..24352e92e 100644
--- a/examples/example-ai-autogen/uv.lock
+++ b/examples/example-ai-autogen/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiofiles"
 version = "25.1.0"
@@ -97,11 +100,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -673,7 +676,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -692,12 +695,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -719,6 +726,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-autogen/uv.toml b/examples/example-ai-autogen/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-autogen/uv.toml
+++ b/examples/example-ai-autogen/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-aws-bedrock/uv.lock b/examples/example-ai-aws-bedrock/uv.lock
index 3d0ba6589..002c854bd 100644
--- a/examples/example-ai-aws-bedrock/uv.lock
+++ b/examples/example-ai-aws-bedrock/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "backoff"
 version = "2.2.1"
@@ -45,11 +48,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -362,7 +365,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -381,12 +384,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -408,6 +415,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-aws-bedrock/uv.toml b/examples/example-ai-aws-bedrock/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-aws-bedrock/uv.toml
+++ b/examples/example-ai-aws-bedrock/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-azure-openai/uv.lock b/examples/example-ai-azure-openai/uv.lock
index 8869e9e36..887d67488 100644
--- a/examples/example-ai-azure-openai/uv.lock
+++ b/examples/example-ai-azure-openai/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-azure-openai/uv.toml b/examples/example-ai-azure-openai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-azure-openai/uv.toml
+++ b/examples/example-ai-azure-openai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-cerebras/uv.lock b/examples/example-ai-cerebras/uv.lock
index 8e6ac73fd..ef3100dc7 100644
--- a/examples/example-ai-cerebras/uv.lock
+++ b/examples/example-ai-cerebras/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-cerebras/uv.toml b/examples/example-ai-cerebras/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-cerebras/uv.toml
+++ b/examples/example-ai-cerebras/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-cloudflare-ai-gateway/uv.lock b/examples/example-ai-cloudflare-ai-gateway/uv.lock
index 98e60b5af..fad13fdb0 100644
--- a/examples/example-ai-cloudflare-ai-gateway/uv.lock
+++ b/examples/example-ai-cloudflare-ai-gateway/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-cloudflare-ai-gateway/uv.toml b/examples/example-ai-cloudflare-ai-gateway/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-cloudflare-ai-gateway/uv.toml
+++ b/examples/example-ai-cloudflare-ai-gateway/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-cohere/uv.lock b/examples/example-ai-cohere/uv.lock
index a48b30504..0e7c2a2a9 100644
--- a/examples/example-ai-cohere/uv.lock
+++ b/examples/example-ai-cohere/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-cohere/uv.toml b/examples/example-ai-cohere/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-cohere/uv.toml
+++ b/examples/example-ai-cohere/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index bf5e38a4c..547ca5a1b 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14'",
@@ -13,6 +13,10 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+uv = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -408,11 +412,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -3883,28 +3887,28 @@ wheels = [
 
 [[package]]
 name = "uv"
-version = "0.11.15"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/da/34/609d5d01ba21dc8f0974610ca7802fbb2c946a0c38665cfe5c5aeddbefb5/uv-0.11.15.tar.gz", hash = "sha256:755f959ec6a2fd8ccb6ee76ad90ab759d2eb1f4797444078645dd1ee4bca92d6", size = 4159545, upload-time = "2026-05-18T19:57:48.133Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/7c/dcc230c5911884d8848145dabcac8fb95a5ed6f9fe1c57fae8242618f28a/uv-0.11.15-py3-none-linux_armv6l.whl", hash = "sha256:83b04ab49514a0a761ffedb36a748ee81f87746671e72088e5f32c9585e5f1a9", size = 23110183, upload-time = "2026-05-18T19:57:23.051Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f3/efd4e044b60eb9c3c12ee386be098d56c335538ccec7caa49349cfba9344/uv-0.11.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b6cae61f737be075b90be9e3f07d961072aed7019f4c9b8ed5c5d41c4d6cade3", size = 22637941, upload-time = "2026-05-18T19:57:26.752Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/b8/48627f895a1569e576822e0a8416aa4797eb4a4551de21a4ad97b9b5819d/uv-0.11.15-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9accae33619a9166e5c48531deb455d672cfb89f9357a00975e669c76b0bd49f", size = 21258803, upload-time = "2026-05-18T19:57:05.473Z" },
-    { url = "https://files.pythonhosted.org/packages/af/50/4bc8a148274feabee2d9c9f1fa15009e10c0228dfe57981ee3ea2ef1d481/uv-0.11.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:c0cf52cd6d50bb9e05e2d968f45f80761107e4cbc8d4a26d9758f9d8274aaec1", size = 23066178, upload-time = "2026-05-18T19:57:33.058Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/56/139fc3bec9a8b0a25bfe2196123adb9f16124da437bf4fbcf0d21cfcafb2/uv-0.11.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:49dc6ed70bff00937384f96cdc4b1a4742d18e5504ec2c4a1214dba2dee5687a", size = 22705332, upload-time = "2026-05-18T19:57:36.714Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/b0/b18b3dd204f8c213236a1ebd148e009861637129a8cce34df0e9aa22ed40/uv-0.11.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:adb9a89352539fdd8f7cd5f9966cf9f94fc5b98e0ccdf5003a04123dc6423bec", size = 22707534, upload-time = "2026-05-18T19:58:04.117Z" },
-    { url = "https://files.pythonhosted.org/packages/76/36/3ca09f95572df99d361b49c96b1297149e96e120d8d1ecf074095a4b6da4/uv-0.11.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40ff67e3f8e8a7533781a2e892a534975a93acb83ea35460e64e7b2bf2111774", size = 24096607, upload-time = "2026-05-18T19:58:11.625Z" },
-    { url = "https://files.pythonhosted.org/packages/64/be/3bdee21a296bbf5336a526e3613d0e7d4538dacc39c62d7fcba55d15f6b0/uv-0.11.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c6463a299ed7e6b5a800ed6f108af8e1588352629424133ddef7572b0e1e1118", size = 25082562, upload-time = "2026-05-18T19:57:40.69Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/73/f371f3689ffe741066468d001d85f739fc4b5574de83b639ef19b5e8a7f4/uv-0.11.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:68c1e62d4b78578b90b833553286b65d6a7e327537716441068583ba652ec4f5", size = 24253391, upload-time = "2026-05-18T19:57:18.47Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/16/fe392d618af6b00c064b3e718d585dcf791546a77c5123a5bec07ce53a0a/uv-0.11.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98edf1bdaf82447014852051d93e3ee95012509c567bf057fd117e6bdbd9a807", size = 24415871, upload-time = "2026-05-18T19:58:19.651Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/24/2e92a052fb6334fcd746d1c7cb57847c204b118c84f5da53c0f9e129f7b7/uv-0.11.15-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:be8f76d25bcf4c92bb384240ac1bf9aa7f51063d0bdeca4c9cf0ec3ed8b145e0", size = 23159007, upload-time = "2026-05-18T19:57:10.653Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/2e/6923d0658d164bb2c435ed1868aa2d49b3074594679917a001ff92dc95bb/uv-0.11.15-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:f9f4fbbf4fe485522054f3c7496c6e8e932d6436e4200ff3daf718db0b7c7bd5", size = 23769385, upload-time = "2026-05-18T19:58:15.856Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/99/7e34cd949e57360814e8064cc9fb7104df445d0f6a663504e5f7473480aa/uv-0.11.15-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:0ed920e896b2fd13a35031707e307e42fbb2681458b967440a17272d86d49137", size = 23860973, upload-time = "2026-05-18T19:57:55.575Z" },
-    { url = "https://files.pythonhosted.org/packages/28/98/8fe1f5f9d816e94569a0298dd8e0936801097625fa1952162951f0d628b6/uv-0.11.15-py3-none-musllinux_1_1_i686.whl", hash = "sha256:41d907611f3e6a13262807fd7f0a17849f76285ca80f536f6b3943732bdc6656", size = 23431392, upload-time = "2026-05-18T19:57:59.814Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/6b/76a1ce2fa860026913a5941700cdc7d715fce9c3277a3fa3489cf2523ca0/uv-0.11.15-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:e3b68f8bf1a4568710f77e5bda9182ce7682811d89a8e7468c22460e032b234d", size = 24519478, upload-time = "2026-05-18T19:57:51.165Z" },
-    { url = "https://files.pythonhosted.org/packages/43/60/1d58e8a05718cb50494763115710b73846cacb651fd735d285233fd72c59/uv-0.11.15-py3-none-win32.whl", hash = "sha256:8e2da3076761086a5b76869c3f38ef0509c836046ef41ddd19485dfd7271dca9", size = 22020178, upload-time = "2026-05-18T19:58:07.64Z" },
-    { url = "https://files.pythonhosted.org/packages/55/53/40fcefcb348af660488597ed3c01363df7344e60611f8883750dc596f5c6/uv-0.11.15-py3-none-win_amd64.whl", hash = "sha256:cc3915ab291a1ecaf31de05f5d8bd70d09c66fe9911a53f70d9efa62ff0dbd8a", size = 24668779, upload-time = "2026-05-18T19:57:44.894Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/7d/fa3a9960c95af9bbe2a629048760d0b9b4fead8ccd4f2235af747ec7cdf0/uv-0.11.15-py3-none-win_arm64.whl", hash = "sha256:4f39426a13dee24897aed60c4b98058c66f18bd983885ac5f4a54a04b24fbddf", size = 23198178, upload-time = "2026-05-18T19:57:14.68Z" },
+version = "0.13.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/55/609455d21e87430c11fe734abfced50a3bdf177b2f49d41fbb19c199cbc3/uv-0.13.4.tar.gz", hash = "sha256:b0bff5b9a5061f7a35b1d0c1a94c19af134222c48eb7aadc42f85a038be1b248", size = 7482486, upload-time = "2026-10-20T15:12:06.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4349da5356b17a1c0e36c8552c809925f86f6292de9b1f599f01e8e8093d/uv-0.13.4-py3-none-linux_armv6l.whl", hash = "sha256:205a4f93e568fb24f45a2f3834f1c0a8f1adb5f396bf473c71030ed707dce048", size = 18272390, upload-time = "2026-10-20T15:11:02.468Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f2/0cb77a1ae43959772f8f7873eb1f4061907fbb1694ce55c79b231f639b1d/uv-0.13.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b4bbacea78c9db136cd2ec3147cbfd9ed910b4db5e1877109bd74d0e73bb2eaf", size = 17384113, upload-time = "2026-10-20T15:11:07.172Z" },
+    { url = "https://files.pythonhosted.org/packages/26/44/5a8733dd1b2e8d6f9cffd1ff6428a3e11dcc7e146a7657e32cfb8d9fb4a4/uv-0.13.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:95f4eb2b991b53b50ec2b18ab612fca8ba1e7a75a47af0331fb8bcd21da3eb03", size = 14433723, upload-time = "2026-10-20T15:11:10.185Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/39/be14f051bf34a1822d634819890a2d0cba3b69101e633fb7b9f54d7b4020/uv-0.13.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:e90ab42825587821096cb0d071e387468da38cfa22818c91f9c0b3c0453048e8", size = 17816443, upload-time = "2026-10-20T15:11:13.674Z" },
+    { url = "https://files.pythonhosted.org/packages/97/a0/5df0f8bc6367dd37b98432a7c462e2918554f6db2a71211574852b8f0727/uv-0.13.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:3a9dcb6762c3ba249d8c084315ba03839082af3ece3536cc4164ec735c351d68", size = 17828025, upload-time = "2026-10-20T15:11:16.806Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9c/2fed5357700b7c304b94214979e4efe680c3bc6e337a97eedaa372fe0947/uv-0.13.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8ae6ff2b07892379dc767c9064c2b8bbfac88e767edac7ce28e1b0f15d86abb4", size = 17843737, upload-time = "2026-10-20T15:11:20.043Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/2e/ee026284f096236dc3e1abed0316f9edab65c0ea176ea0072c064e62478d/uv-0.13.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:25cc14ff4fd8335d3be2cc493a621a003fdafcb0fb1c953c905daabe4def5ab8", size = 18576350, upload-time = "2026-10-20T15:11:24.035Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f1/67fbdb649c8c5d0cb38ea74829080479b77c8631cda5d77fc1b28f027ca7/uv-0.13.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77062b02856c74697f48328d8a6583ab07e6da0a993e86c2db46f3d1da27c637", size = 19831234, upload-time = "2026-10-20T15:11:27.627Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/00/7d49e3a1a3e98e5244fa38e0c964dc8de568bf3bb101257a63dc2602efed/uv-0.13.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fb0e2028d9a8929884344afb7d91d0f65d9783f640d28aede89fca3602bedde9", size = 19702886, upload-time = "2026-10-20T15:11:31.128Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/a1/de02c0913726728eca56ee258875cbba9c7b0572c63f494fd9f55c7852e3/uv-0.13.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e4332791b4d55b6dde8695b7fa6079b26991519f44760887c5dfbd5ca4fe53", size = 17181168, upload-time = "2026-10-20T15:11:34.583Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/cd/f4a3c7377674366798c56aabd0f9a1f05687c3939f5ba857a3ea6093ff84/uv-0.13.4-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:7b3cdf868e5415631fe797b648c0d6945d38d388f23367bdd0b6332e80a1fcb0", size = 16502020, upload-time = "2026-10-20T15:11:37.88Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/f4/ce79657c5a0f51b602db9a663529baafff03b9fe8cc41e09ad3f7246b88a/uv-0.13.4-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:4e6b08578c920b86910897f36bb6da7229c8e7e0187976570e2a538cb28b777e", size = 18000980, upload-time = "2026-10-20T15:11:41.59Z" },
+    { url = "https://files.pythonhosted.org/packages/21/e6/7d77022d5661f8e01578bc5423bf02af408220e7e7ac5ee15eb94742c7cb/uv-0.13.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:d86a5dec8ab30c70519c71ca5085c8aaf28664836cbc600951cedaa3fc678cbf", size = 18179083, upload-time = "2026-10-20T15:11:45.191Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/40/1bf0324800d38009774ba087a6fbffddc76a3e5bf42c081b9298b1236fb5/uv-0.13.4-py3-none-musllinux_1_1_i686.whl", hash = "sha256:5d89d1028c2e22977d9215cbb79cfe12559cb0c8a507a12e2f3a7e47930cf1bf", size = 18010389, upload-time = "2026-10-20T15:11:48.963Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/ec/f352ca2cc3b4b6191bb4ec8cdf4bc190eed0ba8bda4c33b7fd66c5d33cec/uv-0.13.4-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:52b5c753a7c2d5f8323a70bb4c93118988356331d0758afa6446c81f974e7196", size = 19004998, upload-time = "2026-10-20T15:11:52.628Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4f/fc05ff4292edfe785b47874ec86d3d83ca2bf735cff8a9d2170ffb66ad83/uv-0.13.4-py3-none-win32.whl", hash = "sha256:d333f01852b817ba05612de31474739da1af7e5463d119b30a9c4331eba1f408", size = 16190502, upload-time = "2026-10-20T15:11:56.657Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/b9/b526eab6c72eacc705a58378f6850fde046b28c86fed01bd42da61367c6b/uv-0.13.4-py3-none-win_amd64.whl", hash = "sha256:b2ff80397273fff0e02c20eacae6882834c811827d6fc08f658db156fe754386", size = 15331833, upload-time = "2026-10-20T15:11:59.733Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f7/4d5fa89d3d10ff6a84e547ef6e02c45b2f2d50e66682da778acf60db63f1/uv-0.13.4-py3-none-win_arm64.whl", hash = "sha256:deffa5a4afdb48f3e44fb26e80377d256b330ddcad0373daff4b54f6162b43a4", size = 15690151, upload-time = "2026-10-20T15:12:02.74Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-crewai/uv.toml b/examples/example-ai-crewai/uv.toml
index dc82adcd0..82d6114c4 100644
--- a/examples/example-ai-crewai/uv.toml
+++ b/examples/example-ai-crewai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 and uv 0.13.4 drop the compromised eMudhra root and are newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day", uv = "1 day" }
diff --git a/examples/example-ai-dedalus/uv.lock b/examples/example-ai-dedalus/uv.lock
index e0c9775f6..87710ad73 100644
--- a/examples/example-ai-dedalus/uv.lock
+++ b/examples/example-ai-dedalus/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-dedalus/uv.toml b/examples/example-ai-dedalus/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-dedalus/uv.toml
+++ b/examples/example-ai-dedalus/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-deepseek/uv.lock b/examples/example-ai-deepseek/uv.lock
index c17c4abe2..bd66d5ec4 100644
--- a/examples/example-ai-deepseek/uv.lock
+++ b/examples/example-ai-deepseek/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-deepseek/uv.toml b/examples/example-ai-deepseek/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-deepseek/uv.toml
+++ b/examples/example-ai-deepseek/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-dspy/uv.lock b/examples/example-ai-dspy/uv.lock
index 80a8f76aa..cbf103c59 100644
--- a/examples/example-ai-dspy/uv.lock
+++ b/examples/example-ai-dspy/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.11'",
@@ -10,6 +10,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -308,11 +311,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-dspy/uv.toml b/examples/example-ai-dspy/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-dspy/uv.toml
+++ b/examples/example-ai-dspy/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-fireworks-ai/uv.lock b/examples/example-ai-fireworks-ai/uv.lock
index 03c02c70d..978ae3f32 100644
--- a/examples/example-ai-fireworks-ai/uv.lock
+++ b/examples/example-ai-fireworks-ai/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-fireworks-ai/uv.toml b/examples/example-ai-fireworks-ai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-fireworks-ai/uv.toml
+++ b/examples/example-ai-fireworks-ai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-gemini/uv.lock b/examples/example-ai-gemini/uv.lock
index 0f23558c5..f512aff3c 100644
--- a/examples/example-ai-gemini/uv.lock
+++ b/examples/example-ai-gemini/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -576,7 +579,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -595,12 +598,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -622,6 +629,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-gemini/uv.toml b/examples/example-ai-gemini/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-gemini/uv.toml
+++ b/examples/example-ai-gemini/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-groq/uv.lock b/examples/example-ai-groq/uv.lock
index 9c07e662d..3a4b5205b 100644
--- a/examples/example-ai-groq/uv.lock
+++ b/examples/example-ai-groq/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-groq/uv.toml b/examples/example-ai-groq/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-groq/uv.toml
+++ b/examples/example-ai-groq/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-helicone/uv.lock b/examples/example-ai-helicone/uv.lock
index 64778b2f4..28b21350c 100644
--- a/examples/example-ai-helicone/uv.lock
+++ b/examples/example-ai-helicone/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-helicone/uv.toml b/examples/example-ai-helicone/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-helicone/uv.toml
+++ b/examples/example-ai-helicone/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-hugging-face/uv.lock b/examples/example-ai-hugging-face/uv.lock
index 1064d1af9..c911563ad 100644
--- a/examples/example-ai-hugging-face/uv.lock
+++ b/examples/example-ai-hugging-face/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-hugging-face/uv.toml b/examples/example-ai-hugging-face/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-hugging-face/uv.toml
+++ b/examples/example-ai-hugging-face/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-instructor/uv.lock b/examples/example-ai-instructor/uv.lock
index 21bc1548d..6a6d1eace 100644
--- a/examples/example-ai-instructor/uv.lock
+++ b/examples/example-ai-instructor/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -268,11 +271,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -1214,7 +1217,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1233,12 +1236,14 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -1262,6 +1267,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-instructor/uv.toml b/examples/example-ai-instructor/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-instructor/uv.toml
+++ b/examples/example-ai-instructor/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-langchain/uv.lock b/examples/example-ai-langchain/uv.lock
index d8a1b4c62..d72389757 100644
--- a/examples/example-ai-langchain/uv.lock
+++ b/examples/example-ai-langchain/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -827,7 +830,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -846,12 +849,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -873,6 +880,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-langchain/uv.toml b/examples/example-ai-langchain/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-langchain/uv.toml
+++ b/examples/example-ai-langchain/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-langgraph/uv.lock b/examples/example-ai-langgraph/uv.lock
index 1dfeabedd..0fc330260 100644
--- a/examples/example-ai-langgraph/uv.lock
+++ b/examples/example-ai-langgraph/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.11'",
@@ -10,6 +10,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -44,11 +47,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -813,7 +816,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -832,12 +835,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -859,6 +866,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-langgraph/uv.toml b/examples/example-ai-langgraph/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-langgraph/uv.toml
+++ b/examples/example-ai-langgraph/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-litellm/uv.lock b/examples/example-ai-litellm/uv.lock
index 15411cad4..fc58e156f 100644
--- a/examples/example-ai-litellm/uv.lock
+++ b/examples/example-ai-litellm/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -268,11 +271,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-litellm/uv.toml b/examples/example-ai-litellm/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-litellm/uv.toml
+++ b/examples/example-ai-litellm/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index 1a36872ad..f74f56fb4 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.11'",
@@ -10,6 +10,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -290,11 +293,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -1805,7 +1808,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1824,12 +1827,14 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -1853,6 +1858,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-llamaindex/uv.toml b/examples/example-ai-llamaindex/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-llamaindex/uv.toml
+++ b/examples/example-ai-llamaindex/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-mirascope/uv.lock b/examples/example-ai-mirascope/uv.lock
index cd488af90..236ddaeb6 100644
--- a/examples/example-ai-mirascope/uv.lock
+++ b/examples/example-ai-mirascope/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -536,7 +539,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -555,12 +558,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -582,6 +589,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-mirascope/uv.toml b/examples/example-ai-mirascope/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-mirascope/uv.toml
+++ b/examples/example-ai-mirascope/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-mistral/uv.lock b/examples/example-ai-mistral/uv.lock
index c7e00ba96..3ae20625e 100644
--- a/examples/example-ai-mistral/uv.lock
+++ b/examples/example-ai-mistral/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-mistral/uv.toml b/examples/example-ai-mistral/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-mistral/uv.toml
+++ b/examples/example-ai-mistral/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-ollama/uv.lock b/examples/example-ai-ollama/uv.lock
index 9084565ed..88ab43899 100644
--- a/examples/example-ai-ollama/uv.lock
+++ b/examples/example-ai-ollama/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-ollama/uv.toml b/examples/example-ai-ollama/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-ollama/uv.toml
+++ b/examples/example-ai-ollama/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-openai-agents/uv.lock b/examples/example-ai-openai-agents/uv.lock
index a2ffba110..87d85b46d 100644
--- a/examples/example-ai-openai-agents/uv.lock
+++ b/examples/example-ai-openai-agents/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -12,6 +12,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -55,11 +58,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-openai-agents/uv.toml b/examples/example-ai-openai-agents/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-openai-agents/uv.toml
+++ b/examples/example-ai-openai-agents/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-openai/uv.lock b/examples/example-ai-openai/uv.lock
index a4e0c10e1..abd252aa1 100644
--- a/examples/example-ai-openai/uv.lock
+++ b/examples/example-ai-openai/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-openai/uv.toml b/examples/example-ai-openai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-openai/uv.toml
+++ b/examples/example-ai-openai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-openrouter/uv.lock b/examples/example-ai-openrouter/uv.lock
index d48c3c205..2468a06ab 100644
--- a/examples/example-ai-openrouter/uv.lock
+++ b/examples/example-ai-openrouter/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-openrouter/uv.toml b/examples/example-ai-openrouter/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-openrouter/uv.toml
+++ b/examples/example-ai-openrouter/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-perplexity/uv.lock b/examples/example-ai-perplexity/uv.lock
index 6391fc43a..45e91258d 100644
--- a/examples/example-ai-perplexity/uv.lock
+++ b/examples/example-ai-perplexity/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-perplexity/uv.toml b/examples/example-ai-perplexity/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-perplexity/uv.toml
+++ b/examples/example-ai-perplexity/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-portkey/uv.lock b/examples/example-ai-portkey/uv.lock
index fa1e8f543..77d4a6595 100644
--- a/examples/example-ai-portkey/uv.lock
+++ b/examples/example-ai-portkey/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -49,11 +52,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -541,7 +544,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -560,12 +563,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -587,6 +594,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-portkey/uv.toml b/examples/example-ai-portkey/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-portkey/uv.toml
+++ b/examples/example-ai-portkey/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index cac931f92..6679c95fd 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -13,6 +13,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "ag-ui-protocol"
 version = "0.1.14"
@@ -424,11 +427,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -2108,7 +2111,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2127,12 +2130,14 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -2156,6 +2161,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-pydantic-ai/uv.toml b/examples/example-ai-pydantic-ai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-pydantic-ai/uv.toml
+++ b/examples/example-ai-pydantic-ai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-semantic-kernel/uv.lock b/examples/example-ai-semantic-kernel/uv.lock
index 5f8f0ffc8..293cbf9d4 100644
--- a/examples/example-ai-semantic-kernel/uv.lock
+++ b/examples/example-ai-semantic-kernel/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -14,6 +14,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.6.1"
@@ -429,11 +432,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -2011,7 +2014,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.73.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2030,12 +2033,14 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -2059,6 +2064,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-semantic-kernel/uv.toml b/examples/example-ai-semantic-kernel/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-semantic-kernel/uv.toml
+++ b/examples/example-ai-semantic-kernel/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-smolagents/uv.lock b/examples/example-ai-smolagents/uv.lock
index df944934a..7cbaabb7a 100644
--- a/examples/example-ai-smolagents/uv.lock
+++ b/examples/example-ai-smolagents/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -792,7 +795,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.63.0"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -811,12 +814,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -838,6 +845,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-smolagents/uv.toml b/examples/example-ai-smolagents/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-smolagents/uv.toml
+++ b/examples/example-ai-smolagents/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-together-ai/uv.lock b/examples/example-ai-together-ai/uv.lock
index 9dab19c00..eb2c37bd1 100644
--- a/examples/example-ai-together-ai/uv.lock
+++ b/examples/example-ai-together-ai/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-together-ai/uv.toml b/examples/example-ai-together-ai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-together-ai/uv.toml
+++ b/examples/example-ai-together-ai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-vercel-ai-gateway/uv.lock b/examples/example-ai-vercel-ai-gateway/uv.lock
index 641c68ba7..ef3264472 100644
--- a/examples/example-ai-vercel-ai-gateway/uv.lock
+++ b/examples/example-ai-vercel-ai-gateway/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-vercel-ai-gateway/uv.toml b/examples/example-ai-vercel-ai-gateway/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-vercel-ai-gateway/uv.toml
+++ b/examples/example-ai-vercel-ai-gateway/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/examples/example-ai-xai/uv.lock b/examples/example-ai-xai/uv.lock
index 271bc8fce..24f779a26 100644
--- a/examples/example-ai-xai/uv.lock
+++ b/examples/example-ai-xai/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-types"
 version = "0.7.0"
@@ -40,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.2.25"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -509,7 +512,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -528,12 +531,16 @@ otel = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -555,6 +562,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/examples/example-ai-xai/uv.toml b/examples/example-ai-xai/uv.toml
index dc82adcd0..e4a5d8a9d 100644
--- a/examples/example-ai-xai/uv.toml
+++ b/examples/example-ai-xai/uv.toml
@@ -1 +1,3 @@
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
diff --git a/integration_tests/django5/pyproject.toml b/integration_tests/django5/pyproject.toml
index 139cc0457..fe592ad2e 100644
--- a/integration_tests/django5/pyproject.toml
+++ b/integration_tests/django5/pyproject.toml
@@ -15,6 +15,8 @@ dependencies = [
 [tool.uv]
 required-version = ">=0.5"
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
 
 [tool.uv.sources]
 posthog = { path = "../..", editable = true }
diff --git a/integration_tests/django5/uv.lock b/integration_tests/django5/uv.lock
index 68d85d4a7..8f39eb073 100644
--- a/integration_tests/django5/uv.lock
+++ b/integration_tests/django5/uv.lock
@@ -1,11 +1,14 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.12"
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "anyio"
 version = "4.14.2"
@@ -39,11 +42,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.10.5"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -251,7 +254,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.66.0"
+version = "7.75.4"
 source = { editable = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -264,12 +267,14 @@ dependencies = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
     { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
     { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
@@ -293,6 +298,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/playgrounds/fastapi-async-client/pyproject.toml b/playgrounds/fastapi-async-client/pyproject.toml
index 25cebf297..6476cef65 100644
--- a/playgrounds/fastapi-async-client/pyproject.toml
+++ b/playgrounds/fastapi-async-client/pyproject.toml
@@ -10,6 +10,8 @@ dependencies = [
 
 [tool.uv]
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
 
 [tool.uv.sources]
 posthog = { path = "../..", editable = true }
diff --git a/playgrounds/fastapi-async-client/uv.lock b/playgrounds/fastapi-async-client/uv.lock
index b4852cd30..3548a8c74 100644
--- a/playgrounds/fastapi-async-client/uv.lock
+++ b/playgrounds/fastapi-async-client/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.11'",
@@ -10,6 +10,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [[package]]
 name = "annotated-doc"
 version = "0.0.5"
@@ -53,11 +56,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.7.22"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]
@@ -396,7 +399,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.61.1"
+version = "7.75.4"
 source = { editable = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -414,12 +417,16 @@ async = [
 requires-dist = [
     { name = "anthropic", marker = "extra == 'test'", specifier = ">=0.72" },
     { name = "backoff", specifier = ">=1.10.0" },
+    { name = "celery", marker = "extra == 'test'", specifier = ">=5.3,<6" },
     { name = "claude-agent-sdk", marker = "extra == 'test'" },
     { name = "coverage", marker = "extra == 'test'" },
     { name = "distro", specifier = ">=1.5.0" },
     { name = "django", marker = "extra == 'test'", specifier = ">=5.2.15,<6.0" },
     { name = "django-stubs", marker = "extra == 'dev'" },
+    { name = "djangorestframework", marker = "extra == 'test'", specifier = ">=3.15,<4" },
+    { name = "fastapi", marker = "extra == 'test'", specifier = ">=0.115,<1" },
     { name = "fastmcp", marker = "extra == 'test'", specifier = ">=2.0" },
+    { name = "flask", marker = "extra == 'test'", specifier = ">=2.2" },
     { name = "freezegun", marker = "extra == 'test'", specifier = "==1.5.1" },
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
@@ -441,6 +448,7 @@ requires-dist = [
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
diff --git a/pyproject.toml b/pyproject.toml
index 782d41551..75c935ca8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -132,6 +132,8 @@ packages = [
 
 [tool.uv]
 exclude-newer = "7 days"
+# certifi 2026.10.19 drops the compromised eMudhra root and is newer than the 7-day cooldown.
+exclude-newer-package = { certifi = "1 day" }
 required-version = ">=0.8.0"
 
 # Declares a uv workspace so tooling (incl. Sampo's release flow) discovers the
diff --git a/uv.lock b/uv.lock
index 81524ec2c..1a4259f9b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -15,6 +15,9 @@ resolution-markers = [
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
 exclude-newer-span = "P7D"
 
+[options.exclude-newer-package]
+certifi = { timestamp = "0001-01-01T00:00:00Z", span = "P1D" }
+
 [manifest]
 members = [
     "openfeature-provider-posthog",
@@ -497,11 +500,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.6.15"
+version = "2026.10.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/73/f7/f14b46d4bcd21092d7d3ccef689615220d8a08fb25e564b65d20738e672e/certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b", size = 158753, upload-time = "2025-06-15T02:45:51.329Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/ae/320161bd181fc06471eed047ecce67b693fd7515b16d495d8932db763426/certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057", size = 157650, upload-time = "2025-06-15T02:45:49.977Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
 ]
 
 [[package]]

From ffde3c57f26b9daf92f12fbb21edd4f359e4388b Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Fri, 23 Oct 2026 05:16:08 -0400
Subject: [PATCH 092/245] fix(ai): keep streamed OpenAI tool calls that have no
 index (#1091)

* fix(ai): keep streamed OpenAI tool calls that have no index

accumulate_openai_tool_calls skipped every delta without an index, so
tool calls from OpenAI-compatible providers that omit it never reached
$ai_output. A delta with a new id now opens a call, and one without an
id continues the latest call.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix(ai): keep synthetic tool call keys apart from provider indexes

A call without an index took key max + 1, which a later call with that real index overwrote, merging two calls and dropping one. Index-less calls now get string keys of their own.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix(ai): widen the streamed tool call accumulator key type

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(ai): update streamed tool call API snapshot

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .../openai-stream-tool-calls-without-index.md |   5 +
 posthog/ai/openai/_streaming.py               |   4 +-
 posthog/ai/openai/openai_converter.py         |  26 +++-
 .../test/ai/openai/test_openai_converter.py   | 134 +++++++++++++++++-
 references/public_api_snapshot.txt            |   2 +-
 5 files changed, 164 insertions(+), 7 deletions(-)
 create mode 100644 .sampo/changesets/openai-stream-tool-calls-without-index.md

diff --git a/.sampo/changesets/openai-stream-tool-calls-without-index.md b/.sampo/changesets/openai-stream-tool-calls-without-index.md
new file mode 100644
index 000000000..1bc8537d9
--- /dev/null
+++ b/.sampo/changesets/openai-stream-tool-calls-without-index.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Streamed OpenAI-compatible chat completions whose tool call deltas carry no `index` are no longer dropped from `$ai_output`. A delta with a new id starts a call, and one without an id continues the latest call.
diff --git a/posthog/ai/openai/_streaming.py b/posthog/ai/openai/_streaming.py
index 376372687..cc6baf13d 100644
--- a/posthog/ai/openai/_streaming.py
+++ b/posthog/ai/openai/_streaming.py
@@ -1,7 +1,7 @@
 """Sync-neutral state accumulation for OpenAI streaming endpoints."""
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from ..types import StreamingEventData, TokenUsage
 from ..utils import merge_usage_stats, _responses_stop_reason
@@ -52,7 +52,7 @@ class _ChatCompletionsStreamState:
 
     usage_stats: TokenUsage = field(default_factory=lambda: TokenUsage())
     output: List[Any] = field(default_factory=list)
-    _tool_calls: Dict[int, Dict[str, Any]] = field(default_factory=dict)
+    _tool_calls: Dict[Union[int, str], Dict[str, Any]] = field(default_factory=dict)
     model: Optional[str] = None
     stop_reason: Optional[str] = None
     service_tier: Optional[str] = None
diff --git a/posthog/ai/openai/openai_converter.py b/posthog/ai/openai/openai_converter.py
index e0f397ff6..78487d19c 100644
--- a/posthog/ai/openai/openai_converter.py
+++ b/posthog/ai/openai/openai_converter.py
@@ -6,7 +6,7 @@
 Chat Completions API and Responses API formats.
 """
 
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, Union, cast
 
 from posthog.ai.media import to_plain
 from posthog.ai.types import (
@@ -747,7 +747,7 @@ def extract_openai_tool_calls_from_chunk(chunk: Any) -> Optional[List[Dict[str,
 
 
 def accumulate_openai_tool_calls(
-    accumulated_tool_calls: Dict[int, Dict[str, Any]],
+    accumulated_tool_calls: Dict[Union[int, str], Dict[str, Any]],
     chunk_tool_calls: List[Dict[str, Any]],
 ) -> None:
     """
@@ -756,6 +756,8 @@ def accumulate_openai_tool_calls(
     OpenAI sends tool calls incrementally:
     - First chunk has id, type, function.name and partial function.arguments
     - Subsequent chunks have more function.arguments
+    Deltas without an index are matched by id, start a call when they carry an id
+    or a function name, and otherwise continue the latest call.
 
     Args:
         accumulated_tool_calls: Dictionary mapping index to accumulated tool call data
@@ -764,7 +766,25 @@ def accumulate_openai_tool_calls(
     for tool_call_delta in chunk_tool_calls:
         index = tool_call_delta.get("index")
         if index is None:
-            continue
+            # Some OpenAI-compatible providers omit the index. A delta with a new id
+            # or a function name starts a call, and one with neither continues the
+            # latest call. Those calls get keys of their own, so they can never
+            # collide with an index the provider sends later.
+            call_id = tool_call_delta.get("id")
+            index = next(
+                (
+                    key
+                    for key, tc in accumulated_tool_calls.items()
+                    if call_id and tc["id"] == call_id
+                ),
+                None,
+            )
+            if index is None:
+                has_name = bool((tool_call_delta.get("function") or {}).get("name"))
+                if accumulated_tool_calls and not call_id and not has_name:
+                    index = next(reversed(accumulated_tool_calls))
+                else:
+                    index = f"no-index-{len(accumulated_tool_calls)}"
 
         # Initialize tool call if first time seeing this index
         if index not in accumulated_tool_calls:
diff --git a/posthog/test/ai/openai/test_openai_converter.py b/posthog/test/ai/openai/test_openai_converter.py
index a6ee44e6b..2034f533f 100644
--- a/posthog/test/ai/openai/test_openai_converter.py
+++ b/posthog/test/ai/openai/test_openai_converter.py
@@ -9,8 +9,12 @@
 except ImportError:
     OPENAI_AVAILABLE = False
 
-from posthog.ai.openai._streaming import _ResponsesStreamState
+from posthog.ai.openai._streaming import (
+    _ChatCompletionsStreamState,
+    _ResponsesStreamState,
+)
 from posthog.ai.openai.openai_converter import (
+    accumulate_openai_tool_calls,
     extract_openai_stop_reason,
     format_openai_input,
 )
@@ -288,3 +292,131 @@ def test_responses_stream_records_every_terminal_stop_reason(
     )
 
     assert state.stop_reason == expected
+
+
+def _tool_call_chunk(*tool_calls):
+    return types.SimpleNamespace(
+        choices=[
+            types.SimpleNamespace(
+                delta=types.SimpleNamespace(content=None, tool_calls=list(tool_calls)),
+                finish_reason=None,
+            )
+        ],
+        usage=None,
+    )
+
+
+def _tool_call_delta(index=None, id=None, name=None, arguments=None):
+    return types.SimpleNamespace(
+        index=index,
+        id=id,
+        type="function" if id else None,
+        function=types.SimpleNamespace(name=name, arguments=arguments),
+    )
+
+
+def test_stream_tool_calls_without_index_are_kept():
+    # Some OpenAI-compatible providers send each call whole, with no index.
+    state = _ChatCompletionsStreamState()
+    state.process_chunk(
+        _tool_call_chunk(_tool_call_delta(id="call_1", name="a", arguments="{}"))
+    )
+    state.process_chunk(
+        _tool_call_chunk(_tool_call_delta(id="call_2", name="b", arguments='{"x": 1}'))
+    )
+
+    assert [(tc["id"], tc["function"]["name"]) for tc in state.tool_calls] == [
+        ("call_1", "a"),
+        ("call_2", "b"),
+    ]
+    assert state.tool_calls[1]["function"]["arguments"] == '{"x": 1}'
+
+
+def test_stream_tool_calls_without_index_join_argument_fragments():
+    tool_calls = {}
+    accumulate_openai_tool_calls(
+        tool_calls, [{"id": "call_1", "function": {"name": "a", "arguments": '{"q":'}}]
+    )
+    accumulate_openai_tool_calls(tool_calls, [{"function": {"arguments": ' "hi"}'}}])
+    accumulate_openai_tool_calls(
+        tool_calls, [{"id": "call_1", "function": {"arguments": ""}}]
+    )
+
+    assert list(tool_calls.values()) == [
+        {
+            "id": "call_1",
+            "type": "function",
+            "function": {"name": "a", "arguments": '{"q": "hi"}'},
+        }
+    ]
+
+
+def test_stream_tool_calls_with_index_are_unchanged():
+    tool_calls = {}
+    accumulate_openai_tool_calls(
+        tool_calls,
+        [
+            {"index": 0, "id": "call_1", "function": {"name": "a", "arguments": "{"}},
+            {"index": 1, "id": "call_2", "function": {"name": "b", "arguments": "{}"}},
+        ],
+    )
+    accumulate_openai_tool_calls(
+        tool_calls, [{"index": 0, "function": {"arguments": "}"}}]
+    )
+
+    assert tool_calls[0]["function"]["arguments"] == "{}"
+    assert tool_calls[1]["function"]["name"] == "b"
+
+
+def test_stream_tool_calls_without_index_or_id_start_a_call_per_name():
+    tool_calls = {}
+    accumulate_openai_tool_calls(
+        tool_calls, [{"function": {"name": "a", "arguments": '{"x": 1}'}}]
+    )
+    accumulate_openai_tool_calls(
+        tool_calls, [{"function": {"name": "b", "arguments": '{"y": 2}'}}]
+    )
+
+    assert [
+        (tc["function"]["name"], tc["function"]["arguments"])
+        for tc in tool_calls.values()
+    ] == [("a", '{"x": 1}'), ("b", '{"y": 2}')]
+
+
+def test_indexless_call_does_not_corrupt_later_indexed_call():
+    # A call without an index must not take a key that a later real index reuses.
+    tool_calls = {}
+    accumulate_openai_tool_calls(
+        tool_calls, [{"id": "call_b", "function": {"name": "b", "arguments": "{}"}}]
+    )
+    accumulate_openai_tool_calls(
+        tool_calls,
+        [{"index": 0, "id": "call_a", "function": {"name": "a", "arguments": "{}"}}],
+    )
+
+    assert [(tc["id"], tc["function"]["arguments"]) for tc in tool_calls.values()] == [
+        ("call_b", "{}"),
+        ("call_a", "{}"),
+    ]
+
+
+def test_indexless_calls_keep_their_order_around_indexed_ones():
+    tool_calls = {}
+    accumulate_openai_tool_calls(
+        tool_calls,
+        [
+            {"index": 0, "id": "call_a", "function": {"name": "a", "arguments": "{"}},
+            {"id": "call_b", "function": {"name": "b", "arguments": "{}"}},
+            {"index": 0, "function": {"arguments": "}"}},
+            {"id": "call_c", "function": {"name": "c", "arguments": "{}"}},
+        ],
+    )
+
+    assert [
+        (tc["id"], tc["function"]["name"], tc["function"]["arguments"])
+        for tc in tool_calls.values()
+    ] == [
+        ("call_a", "a", "{}"),
+        ("call_b", "b", "{}"),
+        ("call_c", "c", "{}"),
+    ]
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index a7d09a3ff..52cb06d6f 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1369,7 +1369,7 @@ function posthog.ai.media.bytes_to_base64(data: bytes) -> str
 function posthog.ai.media.ensure_serializable(obj: Any) -> Any
 function posthog.ai.media.normalize_part_keys(d: dict) -> dict
 function posthog.ai.media.to_plain(obj: Any) -> Any
-function posthog.ai.openai.openai_converter.accumulate_openai_tool_calls(accumulated_tool_calls: Dict[int, Dict[str, Any]], chunk_tool_calls: List[Dict[str, Any]]) -> None
+function posthog.ai.openai.openai_converter.accumulate_openai_tool_calls(accumulated_tool_calls: Dict[Union[int, str], Dict[str, Any]], chunk_tool_calls: List[Dict[str, Any]]) -> None
 function posthog.ai.openai.openai_converter.extract_openai_content_from_chunk(chunk: Any, provider_type: str = 'chat') -> Optional[Any]
 function posthog.ai.openai.openai_converter.extract_openai_stop_reason(response: Any) -> Optional[str]
 function posthog.ai.openai.openai_converter.extract_openai_tool_calls_from_chunk(chunk: Any) -> Optional[List[Dict[str, Any]]]

From 7f4c9be1c8aa66bf55cb2080cf0775ff4ec28cff Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 09:17:44 +0000
Subject: [PATCH 093/245] chore: Release v7.75.7 [skip ci]

---
 .sampo/changesets/openai-stream-tool-calls-without-index.md | 5 -----
 openfeature-provider/CHANGELOG.md                           | 6 ++++++
 openfeature-provider/pyproject.toml                         | 2 +-
 posthog/CHANGELOG.md                                        | 6 ++++++
 posthog/version.py                                          | 2 +-
 pyproject.toml                                              | 2 +-
 uv.lock                                                     | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/openai-stream-tool-calls-without-index.md

diff --git a/.sampo/changesets/openai-stream-tool-calls-without-index.md b/.sampo/changesets/openai-stream-tool-calls-without-index.md
deleted file mode 100644
index 1bc8537d9..000000000
--- a/.sampo/changesets/openai-stream-tool-calls-without-index.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Streamed OpenAI-compatible chat completions whose tool call deltas carry no `index` are no longer dropped from `$ai_output`. A delta with a new id starts a call, and one without an id continues the latest call.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 2d706fe7c..1c3d0efca 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.121 — 2026-10-23
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.7
+
 ## 0.1.120 — 2026-10-22
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 402ff9796..9b9b811f9 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.120"
+version = "0.1.121"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 0219635ea..ef480700d 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.7 — 2026-10-23
+
+### Patch changes
+
+- [ffde3c5](https://github.com/posthog/posthog-python/commit/ffde3c57f26b9daf92f12fbb21edd4f359e4388b) Streamed OpenAI-compatible chat completions whose tool call deltas carry no `index` are no longer dropped from `$ai_output`. A delta with a new id starts a call, and one without an id continues the latest call. — Thanks @pcbeingused333!
+
 ## 7.75.6 — 2026-10-22
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 4121f4176..49289dc30 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.6"
+VERSION = "7.75.7"
diff --git a/pyproject.toml b/pyproject.toml
index 75c935ca8..38760f748 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.6"
+version = "7.75.7"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 1a4259f9b..51abb7d78 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.120"
+version = "0.1.121"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3024,7 +3024,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.6"
+version = "7.75.7"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From b5eb2debabc7bc6e4e5d033b923d1eef6a6508a6 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 09:17:49 +0000
Subject: [PATCH 094/245] Update generated references

---
 .../posthog-python-references-7.75.7.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.7.json

diff --git a/references/posthog-python-references-7.75.7.json b/references/posthog-python-references-7.75.7.json
new file mode 100644
index 000000000..e6b6c343b
--- /dev/null
+++ b/references/posthog-python-references-7.75.7.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.7",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index ecbda11e3..e6b6c343b 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.6",
+    "version": "7.75.7",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From e65ed67b3a61122c6480c2198c019a493061845c Mon Sep 17 00:00:00 2001
From: Anna Garcia <11654201+turnipdabeets@users.noreply.github.com>
Date: Fri, 23 Oct 2026 05:38:15 -0400
Subject: [PATCH 095/245] docs: require signed commits in contributor docs
 (#1111)

Contributors often open PRs with unsigned commits because signing isn't documented here.
---
 .github/pull_request_template.md | 1 +
 AGENTS.md                        | 1 +
 CONTRIBUTING.md                  | 2 +-
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index ea1215d23..61966a3bf 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -9,6 +9,7 @@
 ## :pencil: Checklist
 <!--- Put an `x` in the boxes that apply -->
 
+- [ ] All commits are signed (see [Commit signing](https://github.com/PostHog/posthog-python/blob/main/CONTRIBUTING.md#commit-signing))
 - [ ] I reviewed the submitted code.
 - [ ] I added tests to verify the changes.
 - [ ] I updated the docs if needed.
diff --git a/AGENTS.md b/AGENTS.md
index 745e91ad7..60e388a4b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -5,6 +5,7 @@ Guidance for coding agents working on the PostHog Python SDK (`posthog`). Runtim
 ## Start here
 
 - Use `uv`; follow [CONTRIBUTING.md](./CONTRIBUTING.md) for setup and [checks](./CONTRIBUTING.md#ci-aligned-checks). Run the smallest relevant tests first.
+- Sign every commit; `main` rejects unsigned commits. Configure signing in the git config you commit with, as described in "Commit signing" in [CONTRIBUTING.md](./CONTRIBUTING.md).
 - For `openfeature-provider/` changes, also follow its [contributor guide](./openfeature-provider/CONTRIBUTING.md); root pytest collection does not cover it.
 - Read [RELEASING.md](./RELEASING.md) when adding changesets or changing builds/publishing. Releases publish both `posthog` and its generated `posthoganalytics` mirror.
 - For public API changes, update/review `references/public_api_snapshot.txt` and run its check as described in the contributor guide.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6625fec0c..6a8503e90 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,7 @@ Thanks for your interest in improving the PostHog Python SDK.
 
 ## Commit signing
 
-This repo requires all commits to be signed. To configure commit signing, see the [PostHog handbook](https://posthog.com/handbook/engineering/security#commit-signing).
+This repo requires all commits to be signed. To configure commit signing, see the [PostHog handbook](https://posthog.com/handbook/engineering/security#commit-signing). Set `commit.gpgsign` to `true` in your git config so that every commit is signed, not only the ones you sign by hand.
 
 ## Setup
 

From d58380e87f38b725ded6d38b870b734056a526e7 Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Fri, 23 Oct 2026 17:18:37 +0700
Subject: [PATCH 096/245] fix(flags): fall back for incompatible local regex
 evaluation (#1108)

* fix(flags): fall back for incompatible local regex evaluation

* fix(flags): defer nested regex quantifiers and fast-path ASCII values

* fix(flags): defer strict-end searches with final newline backtracking

* perf(flags): cache pure regex pattern metadata
---
 .../changesets/local-regex-compatibility.md   |   5 +
 posthog/feature_flags.py                      | 229 +++++++++-
 posthog/test/test_feature_flags_regex.py      | 418 ++++++++++++++++++
 3 files changed, 646 insertions(+), 6 deletions(-)
 create mode 100644 .sampo/changesets/local-regex-compatibility.md
 create mode 100644 posthog/test/test_feature_flags_regex.py

diff --git a/.sampo/changesets/local-regex-compatibility.md b/.sampo/changesets/local-regex-compatibility.md
new file mode 100644
index 000000000..5bba25a54
--- /dev/null
+++ b/.sampo/changesets/local-regex-compatibility.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Defer feature flag regex patterns with unsupported syntax or incompatible matching semantics to server evaluation instead of returning incorrect local results. Preserve portable Unicode matching and make end-of-input anchors strict, matching the flags service.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index 049e2fe4e..66af600c7 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -8,11 +8,13 @@
 import warnings
 from decimal import Decimal
 from enum import Enum
-from typing import Optional
+from functools import lru_cache as _lru_cache
+from typing import NamedTuple, NoReturn, Optional
 
 from posthog import utils as utils
 from posthog.types import FlagValue
-from posthog.utils import convert_to_datetime_aware, is_valid_regex
+from posthog.utils import convert_to_datetime_aware
+from posthog.utils import is_valid_regex as is_valid_regex
 
 __LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
 
@@ -660,6 +662,221 @@ def _parse_numeric_value(value) -> float | None:
     return parsed if math.isfinite(parsed) else None
 
 
+class _RegexMetadata(NamedTuple):
+    regex: re.Pattern[str]
+    uses_word_class: bool
+    uses_space_class: bool
+    uses_end_anchor: bool
+    uses_quantifier_or_alternation: bool
+
+
+@_lru_cache(maxsize=256)
+def _compile_regex(pattern: str) -> Optional[_RegexMetadata]:
+    """Cache only pattern metadata; exceptions are not retained by lru_cache."""
+    # Successful re compilation alone does not establish Rust/fancy-regex compatibility.
+    translated = []
+    class_start = None
+    previous = ""
+    group_has_quantifier = []
+    closed_group_has_quantifier = False
+    uses_word_class = False
+    uses_space_class = False
+    uses_end_anchor = False
+    uses_quantifier_or_alternation = False
+    index = 0
+
+    def defer() -> NoReturn:
+        raise InconclusiveMatchError("Regex requires server evaluation")
+
+    while index < len(pattern):
+        character = pattern[index]
+        if 0xD800 <= ord(character) <= 0xDFFF:
+            defer()
+        if class_start is None:
+            uses_end_anchor |= character == "$"
+            uses_quantifier_or_alternation |= character in "*+?{|"
+            if character == "(":
+                group_has_quantifier.append(False)
+            elif character == ")":
+                closed_group_has_quantifier = (
+                    group_has_quantifier.pop() if group_has_quantifier else False
+                )
+                if group_has_quantifier:
+                    group_has_quantifier[-1] |= closed_group_has_quantifier
+            elif character in "*+?{":
+                # Strict anchors can turn nested repetition into expensive backtracking.
+                if previous == ")" and closed_group_has_quantifier:
+                    defer()
+                if group_has_quantifier:
+                    group_has_quantifier[-1] = True
+        if character == "\\":
+            index += 1
+            if index == len(pattern):
+                translated.append("\\")
+                break
+            escaped = pattern[index]
+            if escaped == "x":
+                digits = pattern[index + 1 : index + 3]
+                if len(digits) != 2 or any(
+                    c not in "0123456789abcdefABCDEF" for c in digits
+                ):
+                    defer()
+                translated.append("\\x" + digits)
+                index += 3
+                previous = "literal"
+                continue
+            if escaped in "bB<>" and class_start is None:
+                # Even short ASCII word-boundary searches can exceed the service's step limit.
+                defer()
+            if escaped not in "dDsSwWbfnrt":
+                if not (0x20 <= ord(escaped) <= 0x7E and not escaped.isalnum()):
+                    defer()
+                if class_start is not None and escaped not in r"\-[]^.$*+?(){}|":
+                    defer()
+            uses_word_class |= escaped in "wW"
+            uses_space_class |= escaped in "sS"
+            translated.append("\\" + escaped)
+            previous = "literal"
+        elif character == "[":
+            if class_start is not None:
+                defer()
+            class_start = index
+            translated.append(character)
+        elif character == "]" and class_start is not None:
+            content_start = class_start + (
+                2 if pattern[class_start + 1 : class_start + 2] == "^" else 1
+            )
+            if index == content_start:
+                defer()
+            class_start = None
+            previous = "literal"
+            translated.append(character)
+        elif class_start is not None:
+            if pattern[index : index + 2] in ("&&", "--", "~~"):
+                defer()
+            # Rust and Python disagree on shorthand endpoints in ranges.
+            if (
+                character == "-"
+                and index + 1 < len(pattern)
+                and pattern[index + 1] != "]"
+            ):
+                if pattern[index + 1 : index + 3] in (
+                    r"\d",
+                    r"\D",
+                    r"\s",
+                    r"\S",
+                    r"\w",
+                    r"\W",
+                ) or (
+                    index >= 2
+                    and pattern[index - 2] == "\\"
+                    and pattern[index - 1] in "dDsSwW"
+                ):
+                    defer()
+            translated.append(character)
+        elif character == "(" and pattern[index + 1 : index + 2] == "?":
+            if pattern[index + 2 : index + 3] != ":":
+                defer()
+            translated.append("(?:")
+            index += 2
+            previous = "("
+        elif character == "{":
+            repetition = re.match(r"\{([0-9]+)(?:,([0-9]*))?\}", pattern[index:])
+            if repetition is None or previous in (
+                "",
+                "|",
+                "(",
+                "^",
+                "$",
+                "empty group",
+                "quantifier",
+            ):
+                defer()
+            if any(
+                len(n) > 10 or int(n) > 0xFFFFFFFF for n in repetition.groups() if n
+            ):
+                defer()
+            translated.append(repetition.group())
+            index += len(repetition.group()) - 1
+            if pattern[index + 1 : index + 2] in ("+", "{"):
+                defer()
+            previous = "quantifier"
+        else:
+            if character in "*+?":
+                if previous in ("^", "$", "empty group") or pattern[
+                    index + 1 : index + 2
+                ] in ("+", "{"):
+                    defer()
+                previous = "quantifier"
+            else:
+                previous = (
+                    "empty group"
+                    if character == ")" and previous in ("(", "empty group")
+                    else character
+                )
+            # Python's $ also matches before a final newline; Rust's default $ is strict.
+            translated.append(r"\Z" if character == "$" else character)
+        index += 1
+
+    try:
+        regex = re.compile("".join(translated))
+    except re.error:
+        return None
+    except Exception as error:
+        raise InconclusiveMatchError(
+            "Regex compilation requires server evaluation"
+        ) from error
+
+    return _RegexMetadata(
+        regex,
+        uses_word_class,
+        uses_space_class,
+        uses_end_anchor,
+        uses_quantifier_or_alternation,
+    )
+
+
+def _match_regex(pattern: str, value: str) -> Optional[bool]:
+    """Return None for invalid shared syntax; raise inconclusive for unsupported cases."""
+    if pattern == "":
+        return True
+    metadata = _compile_regex(pattern)
+    if metadata is None:
+        return None
+    (
+        regex,
+        uses_word_class,
+        uses_space_class,
+        uses_end_anchor,
+        uses_quantifier_or_alternation,
+    ) = metadata
+
+    def defer() -> NoReturn:
+        raise InconclusiveMatchError("Regex requires server evaluation")
+
+    # Tightening $ can expose backtracking on a final LF, including repeated alternatives.
+    if uses_end_anchor and uses_quantifier_or_alternation and value.endswith("\n"):
+        defer()
+
+    # Unicode letters/decimal digits agree, but Rust's word class also includes marks and
+    # joiners, while Python includes other numbers. Python's whitespace adds U+001C..U+001F.
+    if not value.isascii():
+        if any(0xD800 <= ord(c) <= 0xDFFF for c in value):
+            defer()
+        if uses_word_class and any(
+            not c.isascii() and not (c.isalpha() or c.isdecimal()) for c in value
+        ):
+            defer()
+    if uses_space_class and any(c in value for c in "\x1c\x1d\x1e\x1f"):
+        defer()
+    try:
+        return regex.search(value) is not None
+    except Exception as error:
+        raise InconclusiveMatchError(
+            "Regex execution requires server evaluation"
+        ) from error
+
+
 def match_property(
     property, property_values, property_matching_version: int = 1
 ) -> bool:
@@ -752,11 +969,11 @@ def compute_exact_match(value, override_value):
         return matched
 
     if operator in ("regex", "not_regex"):
-        if not is_valid_regex(str(value)):
-            return False
         property_string = "null" if override_value is None else str(override_value)
-        matched = re.compile(str(value)).search(property_string) is not None
-        return not matched if operator == "not_regex" else matched
+        regex_match = _match_regex(str(value), property_string)
+        if regex_match is None:
+            return False
+        return not regex_match if operator == "not_regex" else regex_match
 
     if operator in ["is_date_before", "is_date_after"]:
         try:
diff --git a/posthog/test/test_feature_flags_regex.py b/posthog/test/test_feature_flags_regex.py
new file mode 100644
index 000000000..5819aacc6
--- /dev/null
+++ b/posthog/test/test_feature_flags_regex.py
@@ -0,0 +1,418 @@
+"""Regex compatibility with the flags service's Rust matcher, not just Python re."""
+
+from unittest import mock
+
+import pytest
+
+from posthog.client import Client
+from posthog.feature_flags import (
+    InconclusiveMatchError,
+    match_cohort,
+    match_property,
+    match_property_group,
+)
+from posthog.test.test_utils import FAKE_TEST_API_KEY
+
+
+pytestmark = pytest.mark.filterwarnings(
+    r"ignore:`get_feature_flag` is deprecated:DeprecationWarning"
+)
+
+
+# These constructs either have different native semantics or require service syntax/budgets.
+DEFERRED = [
+    (r"^\p{L}+$", "é"),
+    (r"^\p{L}+$", None),
+    (r"^\P{L}+$", "123"),
+    (r"(?<=a+)b", "aab"),
+    (r"a(?=b)", "ab"),
+    (r"(a)\1", "aa"),
+    (r"(?i)^foo$", "FOO"),
+    (r"(?m)^foo$", "foo\nbar"),
+    (r"\Afoo\z", "foo"),
+    (r"^[a&&b]$", "a"),
+    (r"^[a-z&&[^aeiou]]+$", "bcdf"),
+    (r"^[a-z--b]$", "b"),
+    (r"^[a~~b]$", "~"),
+    (r"^[[:alpha:]]+$", "foo"),
+    (r"[]", "a"),
+    (r"[^]", "a"),
+    (r"\141", "a"),
+    (r"\q", "q"),
+    (r"^\x{41}$", "A"),
+    (r"a++", "aa"),
+    (r"a{,2}", "aa"),
+    (r"a*{2}", "aa"),
+    (r"{foo}", "{foo}"),
+    (r"[\s-9]", "-"),
+    (r"[a-\d]", "-"),
+    (r"^?https?://", "https://a"),
+    (r"$?", "x"),
+    (r"\b+", "x"),
+    (r"{2}", "x"),
+    (r"a|{2}", "x"),
+    (r"({2})", "x"),
+    (r"(?:{2})", "x"),
+    (r"(?:)*", "x"),
+    (r"()+", "x"),
+    (r"(?:){2}", "x"),
+    (r"a{0,4294967296}", "x"),
+    (r"a{4294967296,}", "x"),
+    (r".*\bbot\b.*", "a" * 140),
+    (r".*\Bbot\B.*", "a" * 140),
+    (r"\<foo\>", "foo"),
+    (r"[\@]", "@"),
+    (r"[\B]", "B"),
+    (r"^\w+$", "\u0301"),  # Rust includes combining marks; Python does not.
+    (r"^\W+$", "²"),  # Python includes non-decimal numbers; Rust does not.
+    (r"^\s$", "\x1c"),  # Python's extra ASCII whitespace is not Rust whitespace.
+    (r"^\S$", "\x1f"),
+    ("^.$", "\ud800"),
+    ("\ud800", "x"),
+    (r"^(a+)+$", "aa\n"),
+    (r"^(a+)+$", "aa"),
+    (r"^(?:ab*)+$", "ab"),
+    (r"^(a{1,2}){2}$", "aa"),
+    (r"^(a?b)*$", "ab"),
+    (r"^(a+|b)+$", "a"),
+    (r"^((a+))+$", "aa"),
+    (r"^((a+)b)+$", "ab"),
+    (r"^((a+)*b)+$", "aab"),
+    (r"^(a+)+?$", "aa"),
+    (r"(a+)+", "aa"),
+    (r"^\s$", "\x1d"),
+    (r"^\S$", "\x1e"),
+    (r"^\s+$", "\u2003\x1c"),
+    (r"^\w+$", "a\u0301"),
+    ("^a.$", "a\ud800"),
+    (r"^(a|aa)+$", "aa\n"),
+    (r"^a+$", "aa\n"),
+    (r"^a*$", "a\n"),
+    (r"^a?$", "a\n"),
+    (r"^a{2}$", "aa\n"),
+    (r"^(?:ab|cd){2,3}$", "abcd\n"),
+    (r"^(?:foo|bar)$", "foo\n"),
+    (r"foo|bar$", "foo\n"),
+]
+
+LOCAL = [
+    ("pro", "a pro plan", True),
+    ("^pro$", "a pro plan", False),
+    ("^pro$", "PRO", False),
+    (r"^\d+$", "123", True),
+    (r"^\d+$", "١", True),
+    (r"^\D+$", "é", True),
+    (r"^\w+$", "abc_123", True),
+    (r"^\w+$", "é١", True),
+    (r"^\W+$", "é١", False),
+    (r"^\s$", "\u2003", True),
+    (r"^\s$", "\ufeff", False),
+    ("^.$", "😀", True),
+    ("^é+$", "éé", True),
+    ("^.$", "\r", True),
+    (r"^[\w.+-]+@example\.com$", "a.b+tag@example.com", True),
+    (r"^(?:ab|cd){2,3}$", "abcdab", True),
+    (r"^\\p\{L\}$", r"\p{L}", True),
+    (r"^\(\?i\)$", "(?i)", True),
+    (r"^\x41+$", "AA", True),
+    (r"^nu", None, True),
+    (r"^\++$", "++", True),
+    (r"[\b]", "\b", True),
+    (r"^a\-b$", "a-b", True),
+    (r"\@example\.com$", "a@example.com", True),
+    (r"^a\:b$", "a:b", True),
+    (r"^a\_b$", "a_b", True),
+    (r"^a\=b$", "a=b", True),
+    (r"^a\ b$", "a b", True),
+    (r"^\^?$", "", True),
+    (r"^\${2}$", "$$", True),
+    (r"^\({2}$", "((", True),
+    (r"^\|{2}$", "||", True),
+    (r"^[\^$?]+$", "$?^", True),
+    (r"^[\w-]+$", "a-b", True),
+    ("", "", True),
+    ("", "é", True),
+    ("", None, True),
+    ("", "\r", True),
+    ("^foo$", "foo\n", False),
+    ("^foo$", "foo\nbar", False),
+    ("foo$", "foo\r\n", False),
+    (r"^([+*?])+$", "+*?", True),
+    (r"^(\++)$", "++", True),
+    (r"^(\+)+$", "++", True),
+    (r"^\(+a+\)+$", "(aa)", True),
+    (r"^(a+)(b+)$", "aabb", True),
+    (r"^((ab)){2}$", "abab", True),
+    (r"^([()]+)$", "()", True),
+    (r"^(a)+(b)+$", "aabb", True),
+    (r"^((a)+b)$", "aab", True),
+    (r"^(a+)(?:b)+$", "aabb", True),
+    ("", "\u0301", True),
+    ("^$", "", True),
+    (r"^[+*?{}|]$", "+\n", False),
+    (r"^\+$", "+\n", False),
+    (r"^\|$", "|\n", False),
+    (r"^a\{$", "a{\n", False),
+    (r"^a+\$", "aa$\n", True),
+    (r"^foo\$$", "foo$\n", False),
+    (r"^a+", "aa\n", True),
+    (r"^(?:a|aa)+$", "aa", True),
+]
+
+
+def property_filter(pattern, operator):
+    return {"key": "value", "type": "person", "operator": operator, "value": pattern}
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize("pattern,value", DEFERRED)
+def test_match_property_regex_defers_unsupported(pattern, value, operator):
+    with pytest.raises(InconclusiveMatchError):
+        match_property(property_filter(pattern, operator), {"value": value})
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize("pattern,value,expected", LOCAL)
+def test_match_property_regex_keeps_portable_patterns_local(
+    pattern, value, expected, operator
+):
+    assert match_property(property_filter(pattern, operator), {"value": value}) is (
+        expected if operator == "regex" else not expected
+    )
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize("pattern", ["[", "(", "*", "?*"])
+@pytest.mark.parametrize("value", ["value", "é", "\r"])
+def test_match_property_regex_invalid_is_false_for_both_operators(
+    pattern, value, operator
+):
+    assert match_property(property_filter(pattern, operator), {"value": value}) is False
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize("pattern", [r"*foo$", r"(a|b$"])
+def test_match_property_regex_invalid_precedes_final_newline_policy(pattern, operator):
+    assert (
+        match_property(property_filter(pattern, operator), {"value": "foo\n"}) is False
+    )
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+def test_match_property_regex_compile_resource_failure_is_inconclusive(operator):
+    with pytest.raises(InconclusiveMatchError):
+        match_property(
+            property_filter("(" * 1000 + "a" + ")" * 1000, operator), {"value": "a"}
+        )
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize("negation", [False, True])
+@pytest.mark.parametrize("pattern", [r"\p{L}+", r"(é+)+"])
+def test_match_property_regex_cohort_does_not_negate_inconclusive(
+    operator, negation, pattern
+):
+    prop = {**property_filter(pattern, operator), "negation": negation}
+    with pytest.raises(InconclusiveMatchError):
+        match_property_group({"type": "AND", "values": [prop]}, {"value": "é"}, {})
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize(
+    "pattern,value",
+    [(r"\p{L}+", "é"), (r".*\bbot\b.*", "a" * 140), (r"^(a+)+$", "aa\n")],
+)
+def test_match_cohort_regex_not_in_does_not_negate_inconclusive(
+    operator, pattern, value
+):
+    cohorts = {"1": {"type": "AND", "values": [property_filter(pattern, operator)]}}
+    with pytest.raises(InconclusiveMatchError):
+        match_cohort(
+            {"value": 1, "operator": "not_in", "type": "cohort"},
+            {"value": value},
+            cohorts,
+        )
+
+
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+@pytest.mark.parametrize(
+    "pattern,cases",
+    [
+        (r"^\w+$", [("abc", True), ("a\u0301", "defer"), ("!", False), ("é١", True)]),
+        (
+            r"^\s+$",
+            [
+                (" ", True),
+                ("\x1c", "defer"),
+                ("\u2003", True),
+                ("\u2003\x1c", "defer"),
+                ("\ufeff", False),
+            ],
+        ),
+        (r"^a+$", [("aa", True), ("aa\n", "defer"), ("b", False)]),
+        (r"^.$", [("😀", True), ("\ud800", "defer"), ("\n", False), ("\r", True)]),
+        (r"^é+$", [("é", True), ("é\n", "defer"), ("foo", False)]),
+        ("[", [("value", "invalid"), ("value\n", "invalid"), ("\ud800", "invalid")]),
+        (r"\p{L}", [("abc", "defer"), ("é", "defer"), ("\n", "defer")]),
+    ],
+)
+def test_match_property_regex_same_pattern_different_values(pattern, cases, operator):
+    for sequence in (cases, list(reversed(cases))):
+        for value, expected in sequence:
+            prop = property_filter(pattern, operator)
+            if expected == "defer":
+                with pytest.raises(InconclusiveMatchError):
+                    match_property(prop, {"value": value})
+            elif expected == "invalid":
+                assert match_property(prop, {"value": value}) is False
+            else:
+                assert match_property(prop, {"value": value}) is (
+                    expected if operator == "regex" else not expected
+                )
+
+
+@pytest.fixture
+def regex_pattern_cache():
+    from posthog.feature_flags import _compile_regex
+
+    _compile_regex.cache_clear()
+    yield _compile_regex
+    _compile_regex.cache_clear()
+
+
+def test_regex_pattern_cache_reuses_metadata_not_match_results(regex_pattern_cache):
+    prop = property_filter("^cached$", "regex")
+    assert match_property(prop, {"value": "cached"}) is True
+    assert match_property(prop, {"value": "other"}) is False
+    assert (
+        match_property(property_filter("^cached$", "not_regex"), {"value": "other"})
+        is True
+    )
+    info = regex_pattern_cache.cache_info()
+    assert (info.misses, info.hits, info.currsize) == (1, 2, 1)
+    metadata = regex_pattern_cache("^cached$")
+    assert regex_pattern_cache("^cached$") is metadata
+    with pytest.raises(AttributeError):
+        metadata.uses_word_class = True
+
+
+def test_regex_pattern_cache_is_bounded_and_evicts_least_recently_used(
+    regex_pattern_cache,
+):
+    first = regex_pattern_cache("^cache-first$")
+    second = regex_pattern_cache("^cache-second$")
+    limit = regex_pattern_cache.cache_info().maxsize
+    assert limit == 256
+    for index in range(limit - 2):
+        regex_pattern_cache(f"^cache-{index}$")
+    assert regex_pattern_cache("^cache-first$") is first
+    regex_pattern_cache("^cache-overflow$")
+    info = regex_pattern_cache.cache_info()
+    assert info.currsize == limit
+    assert regex_pattern_cache("^cache-first$") is first
+    assert regex_pattern_cache.cache_info().misses == info.misses
+    assert regex_pattern_cache("^cache-second$") is not second
+    assert regex_pattern_cache.cache_info().misses == info.misses + 1
+    assert regex_pattern_cache.cache_info().currsize == limit
+
+
+def test_regex_pattern_cache_reuses_invalid_classification(regex_pattern_cache):
+    assert regex_pattern_cache("[") is None
+    for operator in ("regex", "not_regex"):
+        assert match_property(property_filter("[", operator), {"value": "x\n"}) is False
+    info = regex_pattern_cache.cache_info()
+    assert (info.misses, info.hits, info.currsize) == (1, 2, 1)
+
+
+def test_regex_pattern_cache_does_not_retain_exceptions(regex_pattern_cache):
+    errors = []
+    for _ in range(2):
+        with pytest.raises(InconclusiveMatchError) as raised:
+            regex_pattern_cache(r"\p{L}")
+        errors.append(raised.value)
+    assert errors[0] is not errors[1]
+    info = regex_pattern_cache.cache_info()
+    assert (info.misses, info.hits, info.currsize) == (2, 0, 0)
+
+
+def test_regex_empty_pattern_bypasses_pattern_cache(regex_pattern_cache):
+    for operator in ("regex", "not_regex"):
+        for value in ("", "é", "\n"):
+            assert match_property(property_filter("", operator), {"value": value}) is (
+                operator == "regex"
+            )
+    info = regex_pattern_cache.cache_info()
+    assert (info.misses, info.hits, info.currsize) == (0, 0, 0)
+
+
+@pytest.fixture
+def client():
+    instance = Client(FAKE_TEST_API_KEY, send=False)
+    yield instance
+    instance.shutdown()
+
+
+@pytest.mark.parametrize("api", ["evaluate_flags", "get_feature_flag"])
+@pytest.mark.parametrize("operator", ["regex", "not_regex"])
+def test_regex_public_fallback_boundaries(client, api, operator):
+    cases = [(p, {"value": v}, None) for p, v in DEFERRED]
+    cases += [
+        (p, {"value": v}, expected if operator == "regex" else not expected)
+        for p, v, expected in LOCAL
+    ]
+    cases += [
+        ("[", {"value": "x"}, False),
+        (r"*foo$", {"value": "foo\n"}, False),
+        (r"(a|b$", {"value": "foo\n"}, False),
+        ("safe", {}, None),
+    ]
+    with (
+        mock.patch("posthog.client.flags") as remote,
+        mock.patch.object(Client, "capture"),
+    ):
+        remote.return_value = {
+            "flags": {"regex-flag": {"enabled": True, "variant": None}}
+        }
+        for pattern, properties, local_result in cases:
+            client.feature_flags = [
+                {
+                    "id": 1,
+                    "key": "regex-flag",
+                    "active": True,
+                    "filters": {
+                        "groups": [
+                            {
+                                "properties": [property_filter(pattern, operator)],
+                                "rollout_percentage": 100,
+                            }
+                        ]
+                    },
+                }
+            ]
+            for local_only in (False, True):
+                remote.reset_mock()
+                kwargs = {
+                    "person_properties": properties,
+                    "only_evaluate_locally": local_only,
+                }
+                if api == "evaluate_flags":
+                    result = client.evaluate_flags("user-1", **kwargs).get_flag(
+                        "regex-flag"
+                    )
+                else:
+                    result = client.get_feature_flag(
+                        "regex-flag", "user-1", send_feature_flag_events=False, **kwargs
+                    )
+                expected = (
+                    (None if local_only else True)
+                    if local_result is None
+                    else local_result
+                )
+                assert result is expected, (
+                    api,
+                    operator,
+                    pattern,
+                    properties,
+                    local_only,
+                )
+                assert remote.call_count == int(local_result is None and not local_only)

From 72e013122e07345a827d108de74f079672220f1d Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 10:22:51 +0000
Subject: [PATCH 097/245] chore: Release v7.75.8 [skip ci]

---
 .sampo/changesets/local-regex-compatibility.md | 5 -----
 openfeature-provider/CHANGELOG.md              | 6 ++++++
 openfeature-provider/pyproject.toml            | 2 +-
 posthog/CHANGELOG.md                           | 6 ++++++
 posthog/version.py                             | 2 +-
 pyproject.toml                                 | 2 +-
 uv.lock                                        | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/local-regex-compatibility.md

diff --git a/.sampo/changesets/local-regex-compatibility.md b/.sampo/changesets/local-regex-compatibility.md
deleted file mode 100644
index 5bba25a54..000000000
--- a/.sampo/changesets/local-regex-compatibility.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Defer feature flag regex patterns with unsupported syntax or incompatible matching semantics to server evaluation instead of returning incorrect local results. Preserve portable Unicode matching and make end-of-input anchors strict, matching the flags service.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 1c3d0efca..41701c155 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.122 — 2026-10-23
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.8
+
 ## 0.1.121 — 2026-10-23
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 9b9b811f9..c2f161eb5 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.121"
+version = "0.1.122"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index ef480700d..5daf73be8 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.8 — 2026-10-23
+
+### Patch changes
+
+- [d58380e](https://github.com/posthog/posthog-python/commit/d58380e87f38b725ded6d38b870b734056a526e7) Defer feature flag regex patterns with unsupported syntax or incompatible matching semantics to server evaluation instead of returning incorrect local results. Preserve portable Unicode matching and make end-of-input anchors strict, matching the flags service. — Thanks @marandaneto!
+
 ## 7.75.7 — 2026-10-23
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 49289dc30..42ba1010a 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.7"
+VERSION = "7.75.8"
diff --git a/pyproject.toml b/pyproject.toml
index 38760f748..d77bc3082 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.7"
+version = "7.75.8"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 51abb7d78..fe2c8245b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.121"
+version = "0.1.122"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3024,7 +3024,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.7"
+version = "7.75.8"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From a020e703fd89e4e35211419ad6f1ba3b656d798f Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 10:22:57 +0000
Subject: [PATCH 098/245] Update generated references

---
 .../posthog-python-references-7.75.8.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.8.json

diff --git a/references/posthog-python-references-7.75.8.json b/references/posthog-python-references-7.75.8.json
new file mode 100644
index 000000000..bacd9eaf2
--- /dev/null
+++ b/references/posthog-python-references-7.75.8.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.8",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index e6b6c343b..bacd9eaf2 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.7",
+    "version": "7.75.8",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From efc866ec4b18115518597bfa9f6b82a6f17cc270 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Fri, 23 Oct 2026 06:47:19 -0400
Subject: [PATCH 099/245] fix(examples): use gpt-image-2.5-flare in the OpenAI
 image generation example (#1109)

OpenAI shuts down gpt-image-1 on 2026-10-23 and lists gpt-image-2.5-sunburst or
gpt-image-2.5-flare as the replacement
(https://developers.openai.com/api/docs/deprecations).

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 examples/example-ai-openai/image_generation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/example-ai-openai/image_generation.py b/examples/example-ai-openai/image_generation.py
index 8948bb427..9e82ea3ba 100644
--- a/examples/example-ai-openai/image_generation.py
+++ b/examples/example-ai-openai/image_generation.py
@@ -31,7 +31,7 @@
 client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])
 
 response = client.images.generate(
-    model="gpt-image-1",
+    model="gpt-image-2.5-flare",
     prompt="A hedgehog wearing a PostHog t-shirt, pixel art style",
     size="1024x1024",
 )

From 8cd8eb5b6fdcdb19db4c4d07fe911c6eb3976d5a Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Fri, 23 Oct 2026 15:10:22 +0300
Subject: [PATCH 100/245] fix(mcp): send one $mcp_initialize per initialize
 request (#1103)

* fix(mcp): send one $mcp_initialize per initialize request

The Python MCP SDK answers initialize itself, so posthog.mcp sent the
event on the first request of each session, once per process. A
stateless fleet sent one event per pod. A client that sent only
initialize sent no event.

Now MCP SDK 2.x reports the event from Server.middleware, on every
transport. MCP SDK 1.x over HTTP reports it from
PostHogMcpStatelessSessionMiddleware, which takes a new optional
server= argument. MCP SDK 1.x over stdio keeps the first-request
fallback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(mcp): read only the initialize response head on mcp 1.x

The mcp 1.x hook now keeps only the status and the Mcp-Session-Id header
of the initialize response. It no longer parses the JSON or SSE body.
The event uses the protocol version that the client asked for.

record_initialize now reads the client name, version, and protocol from
the initialize params and reply, so both hooks pass them through. The
new tests share their request helpers and drop the SSE body case.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): address review on the initialize hooks

- SSE transport: the initialize event now lands in the session that the
  SSE calls use. On SDK 1.x the middleware leaves SSE requests to the
  first-request fallback. On SDK 2.x the hook uses the process session.
- The bound middleware marks each request that it passes on. The fallback
  now stops only for marked requests, not for every HTTP request.
- The hooks compute the handshake session without a write to the shared
  session that McpAnalytics.capture() reads.
- A server= value that cannot be bound no longer breaks requests.
- Remove the unused _mint_token_if_initialize.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): wait for the initialize capture inside its handshake task

Both handshake hooks run record_initialize in a tracked background task.
It started the capture as a second task, after flush() took its snapshot
of pending tasks. With a slow before_send, flush() returned early and
shutdown dropped $mcp_initialize. The handshake task now awaits the
capture itself.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): resolve the v2 handshake session from an incoming header

On MCP SDK 2.x, a stateless client can send initialize with an existing
Mcp-Session-Id and keep sending it. Its later calls resolve their
session from that header, but the handshake hook read only the
connection id and the minted token. The event landed in a generated
session. The hook now falls back to the incoming header.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): capture a v1 initialize that carries a session header

On MCP SDK 1.x, the middleware read the body only of a POST with no
Mcp-Session-Id, because only those need a token. A client that sent
initialize with an existing session id got no event: the middleware
marked the request, so the first-request fallback did not run either.

A middleware bound to a server now reads those bodies too, behind a
cheap check for "initialize". It still mints only without a header. The
event uses the header that the client keeps sending.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): pass a disconnect mid-body through the session middleware

When the client disconnected while it sent the body, the middleware
stopped its read and replayed the partial body as a complete request.
The app parsed half a request and never saw the disconnect. The
middleware now replays the partial body with more_body set, then hands
the app the disconnect.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): stop buffering tool calls once they are not an initialize

A bound middleware reads the body of a POST that carries a session id,
to catch an initialize that reuses one. That held every tool call in
memory, up to 256 KB, before the app saw it. The middleware now stops
after 4 KB when "initialize" is not in it, and streams the rest.
JSON-RPC clients put "method" before "params", so a handshake shows up
in that window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(mcp): read the v2 handshake header through _resolve_ctx

The v2 handshake hook read the Mcp-Session-Id header and decoded the
token itself. Every later request gets the same pair from _resolve_ctx.
The hook now calls it, so the handshake and later requests follow one
rule and cannot drift apart into two sessions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): run the initialize callbacks inline in the handshake request

Both handshake hooks ran identify and event_properties in a detached
background task. If a callback never returned, each handshake left one
more task pending, with no bound, and flush() waited for all of them.
The spec requires pending state to be bounded by count.

The hooks now run the callbacks inline, the same as a tool call does. A
hung callback holds that request, where the host sees it, and leaves no
task behind. The capture still runs in the background after the
callbacks, as for every other event.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): record the v1 handshake inside the request's auth context

The session middleware sits outside FastMCP's AuthContextMiddleware. It
ran identify after the app returned, when that middleware had already
reset the authenticated user. An identify that calls get_access_token()
got None, so $mcp_initialize stayed anonymous under OAuth. The
middleware now records the handshake when the response starts, while
the app still handles the request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): stop the body peek only on a method that is not initialize

The 4 KB peek stopped when "initialize" was not in the first 4 KB. JSON
key order is arbitrary, so an initialize with large params before its
method got no event. The peek now stops only when the prefix shows a
"method" and no "initialize". Without a method yet, it reads up to the
full cap.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): drop the body byte checks from the session middleware

The middleware guessed from raw bytes whether a request was initialize.
A nested "method" key in params stopped the 4 KB peek too early, and a
JSON-escaped "initialize" failed the quick byte check. That second
case also stopped the token mint, which worked before this PR.

The middleware now parses the body as JSON, as main does, and reads
only requests with no Mcp-Session-Id. On MCP SDK 1.x, an initialize
that reuses an existing session id is not captured. The README lists
this limit. MCP SDK 2.x still captures it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../mcp-initialize-per-handshake.md           |  11 +
 posthog/mcp/README.md                         |  32 +-
 posthog/mcp/__init__.py                       |  15 +-
 posthog/mcp/_instrument_v2.py                 |  90 +-
 posthog/mcp/_instrumentation.py               |  95 +-
 posthog/mcp/_internal.py                      |  17 +
 posthog/mcp/asgi.py                           | 203 +++-
 posthog/mcp/session.py                        |  19 +
 posthog/test/mcp/test_initialize_handshake.py | 990 ++++++++++++++++++
 posthog/test/mcp/test_session_token.py        |  30 +
 posthog/test/mcp/test_v2_lowlevel.py          |   6 +-
 posthog/test/mcp/test_v2_mcpserver.py         |   6 +-
 references/public_api_snapshot.txt            |   3 +-
 13 files changed, 1464 insertions(+), 53 deletions(-)
 create mode 100644 .sampo/changesets/mcp-initialize-per-handshake.md
 create mode 100644 posthog/test/mcp/test_initialize_handshake.py

diff --git a/.sampo/changesets/mcp-initialize-per-handshake.md b/.sampo/changesets/mcp-initialize-per-handshake.md
new file mode 100644
index 000000000..33d926d09
--- /dev/null
+++ b/.sampo/changesets/mcp-initialize-per-handshake.md
@@ -0,0 +1,11 @@
+---
+pypi/posthog: patch
+---
+
+MCP analytics now sends one `$mcp_initialize` for each `initialize` request that a client sends.
+
+Before, the SDK sent the event on the first request of each session, once per process. A stateless fleet sent one event for each pod that a session reached. A conversation-anchored session sent another event. A client that connected and sent no other request sent no event.
+
+On MCP SDK 2.x, the event comes from `Server.middleware` on every transport. Requests on the 2026-07-28 spec, which has no `initialize`, no longer send one. On MCP SDK 1.x over HTTP, the event comes from `PostHogMcpStatelessSessionMiddleware`. The apps that `instrument()` autowires get this with no change. If you mount the middleware by hand, pass the server as `server=`. MCP SDK 1.x over stdio keeps the first request as the trigger.
+
+The event now also has the handshake request as `$mcp_parameters`. On MCP SDK 2.x, it also has the server reply as `$mcp_response`.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index 9db9bc31e..7f3133f2f 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -67,6 +67,31 @@ The value must contain 1 to 256 characters. The SDK records it as
 `$mcp_server_build` on all MCP events. `PostHogMCP.capture()` also adds it to
 custom events unless the event provides its own value.
 
+## When the SDK sends `$mcp_initialize`
+
+One `$mcp_initialize` per `initialize` request the client sends, in the session
+its later requests belong to. A client that reconnects five times reports five,
+however many pods its requests land on. A client that connects and leaves still
+reports one. Requests on the 2026-07-28 revision, which has no `initialize`,
+report none.
+
+The MCP SDK answers `initialize` itself, so the SDK observes it from outside:
+
+- **MCP SDK 2.x**: through `Server.middleware`, on every transport.
+- **MCP SDK 1.x over HTTP**: through `PostHogMcpStatelessSessionMiddleware`, which
+  `instrument()` adds to the apps it autowires. If you mount the middleware
+  yourself, pass the server: `app.add_middleware(PostHogMcpStatelessSessionMiddleware, server=mcp)`.
+  Without it, each pod reports the session's first request as its initialize.
+  The deprecated SSE transport also uses the session's first request.
+  The middleware reads only requests that carry no `Mcp-Session-Id`, so an
+  `initialize` that reuses an existing session id reports none.
+- **MCP SDK 1.x over stdio**: from the session's first request. A stdio server
+  serves one client, so this misses only a client that never sends a request.
+
+`identify` and `event_properties` run for the handshake too. On MCP SDK 1.x the
+SDK has no request context for it, so `extra["ctx"]` carries only `.request`.
+`get_request_headers(extra)` works the same as for any other request.
+
 ## Capture safe input field names
 
 Tool-call events include `$mcp_input_keys`. The SDK records names from the
@@ -385,11 +410,14 @@ a fragmented per-process id. Add the middleware to your app explicitly:
 from posthog.mcp import PostHogMcpStatelessSessionMiddleware, get_mcp_session
 
 app = mcp.streamable_http_app()
-app.add_middleware(PostHogMcpStatelessSessionMiddleware)
+app.add_middleware(PostHogMcpStatelessSessionMiddleware, server=mcp)
 ```
 
+`server=` lets the middleware capture `$mcp_initialize` from the handshake (see
+[When the SDK sends `$mcp_initialize`](#when-the-sdk-sends-mcp_initialize)).
+
 This is also the path for a custom `PostHogMCP` dispatcher (you own the ASGI app),
-where you then read the recovered session per request:
+where you leave `server=` out and read the recovered session per request:
 
 ```python
 sess = get_mcp_session(request)   # sess.session_id, sess.client_name, ...
diff --git a/posthog/mcp/__init__.py b/posthog/mcp/__init__.py
index 70d37eb48..98a73bede 100644
--- a/posthog/mcp/__init__.py
+++ b/posthog/mcp/__init__.py
@@ -51,6 +51,7 @@
     MCPAnalyticsData,
     get_server_tracking_data,
     set_server_tracking_data,
+    tracking_key,
 )
 from .logger import log, set_logger
 from .posthog_mcp import PostHogMCP
@@ -226,18 +227,6 @@ def _warn_if_unsupported_mcp_version() -> None:
         )
 
 
-def _canonical_server(server: Any) -> Any:
-    """The underlying low-level server for high-level wrappers (SDK 1.x FastMCP and
-    jlowin's fastmcp expose ``_mcp_server``; SDK 2.x MCPServer renamed it
-    ``_lowlevel_server``), else the server itself. Used as the tracking key so
-    instrumenting a wrapper and its underlying server resolve to one state instead
-    of two divergent ones (matching the TS SDK)."""
-    low_level = getattr(server, "_mcp_server", None) or getattr(
-        server, "_lowlevel_server", None
-    )
-    return low_level if low_level is not None else server
-
-
 def instrument(
     server: Any,
     posthog_client: Optional[Client] = None,
@@ -286,7 +275,7 @@ def instrument(
     if feedback_options is not None:
         get_feedback_tool_descriptor(feedback_options)
 
-    key = _canonical_server(server)
+    key = tracking_key(server)
 
     try:
         # MCP is an optional peer: load adapters only when instrumentation is
diff --git a/posthog/mcp/_instrument_v2.py b/posthog/mcp/_instrument_v2.py
index 843f2d032..58d45f778 100644
--- a/posthog/mcp/_instrument_v2.py
+++ b/posthog/mcp/_instrument_v2.py
@@ -33,6 +33,7 @@
 import time
 from collections.abc import Mapping
 from dataclasses import replace
+from datetime import datetime, timezone
 from typing import Any, Dict, FrozenSet, Optional, Set, Tuple
 
 import mcp.types as mcp_types
@@ -48,12 +49,15 @@
     advertised_tool_names,
     apply_virtual_tool_injection,
     collect_listed_tools,
+    _is_sse_request,
+    _to_jsonable,
     copy_tools_list_result,
     is_first_listing_page,
     mutate_tool_schema,
     params_to_request_dict,
     prepare_request,
     raw_listing_owns_tool_name,
+    record_initialize,
     record_resource_request,
     resource_listing_response,
     resolve_session_and_client,
@@ -70,9 +74,11 @@
 )
 from ._output_instructions import mirror_instructions_into_structured_content
 from ._tool_input import get_registered_tool_input_schema
+from .asgi import get_mcp_session
 from .logger import log
 from .request_headers import get_request_headers
-from .session_token import read_mcp_session_header
+from .session import handshake_session_id
+from .session_token import SessionTokenPayload, read_mcp_session_header
 from .tools import (
     get_more_tools_result_text,
 )
@@ -111,6 +117,7 @@ def instrument_mcpserver_v2(server: Any, data: MCPAnalyticsData) -> None:
     for method, event_type in _RESOURCE_METHODS.items():
         _wrap_v2_resource_request(low_level, data, method, event_type)
     _patch_add_request_handler(low_level, data, wrap_call=False, high_level=server)
+    _observe_initialize(low_level, data)
 
 
 def instrument_lowlevel_v2(server: Any, data: MCPAnalyticsData) -> None:
@@ -126,6 +133,87 @@ def instrument_lowlevel_v2(server: Any, data: MCPAnalyticsData) -> None:
     for method, event_type in _RESOURCE_METHODS.items():
         _wrap_v2_resource_request(server, data, method, event_type)
     _patch_add_request_handler(server, data, wrap_call=True)
+    _observe_initialize(server, data)
+
+
+# --- initialize ------------------------------------------------------------------
+
+
+def _observe_initialize(server: Any, data: MCPAnalyticsData) -> None:
+    """Emit ``$mcp_initialize`` from the real handshake via ``Server.middleware``.
+
+    mcp 2.x refuses a request handler for ``initialize`` and points at
+    ``Server.middleware`` instead, which wraps every inbound request on every
+    transport, ``initialize`` included. The host callbacks run inline, as they do
+    for a tool call: a hung ``identify`` hangs this handshake, where the client
+    sees it, and leaves no task behind. The runner parks the connection's read
+    loop until the chain returns, but a client sends nothing else before the
+    ``initialize`` reply."""
+    middleware = getattr(server, "middleware", None)
+    if not isinstance(middleware, list):
+        log(
+            "Warning: this MCP server has no Server.middleware list; "
+            "$mcp_initialize falls back to the first request of each session."
+        )
+        return
+    if not any(getattr(entry, _WRAPPED_FLAG, False) for entry in middleware):
+
+        async def observe_initialize(ctx: Any, call_next: Any) -> Any:
+            if getattr(ctx, "method", None) != "initialize":
+                return await call_next(ctx)
+            started = datetime.now(timezone.utc)
+            result = await call_next(ctx)
+            await _record_v2_initialize(data, ctx, result, started)
+            return result
+
+        setattr(observe_initialize, _WRAPPED_FLAG, True)
+        middleware.append(observe_initialize)
+    data.handshake_observed_in_process = True
+
+
+def _initialize_session(
+    ctx: Any,
+) -> Tuple[Optional[str], Optional[SessionTokenPayload]]:
+    """The ``(mcp_session_id, token)`` every later request of this connection will
+    resolve its session from.
+
+    A stateful transport has already assigned the id it returns in the
+    ``Mcp-Session-Id`` header; ``ServerSession`` keeps it on its connection and
+    exposes no public accessor. A stateless one has none: the session comes from
+    the ``Mcp-Session-Id`` the client sent, which it keeps sending, read the way
+    :func:`_resolve_ctx` reads it for every later request, or else from the token
+    our ASGI middleware minted for this response. stdio has neither and resolves
+    to this process's own session, as its later requests do."""
+    if _is_sse_request({"ctx": ctx}):
+        # The SSE transport keys its session on a query parameter that later
+        # requests do not resolve from: they land in this process's own session.
+        return None, None
+    connection = getattr(getattr(ctx, "session", None), "_connection", None)
+    transport_session_id = getattr(connection, "session_id", None)
+    if isinstance(transport_session_id, str) and transport_session_id:
+        return transport_session_id, None
+    token, _, _, _, incoming = _resolve_ctx(ctx)
+    if incoming:
+        return incoming, token
+    request = getattr(ctx, "request", None)
+    return None, get_mcp_session(request) if request is not None else None
+
+
+async def _record_v2_initialize(
+    data: MCPAnalyticsData, ctx: Any, result: Any, started: datetime
+) -> None:
+    try:
+        mcp_session_id, token = _initialize_session(ctx)
+        await record_initialize(
+            data,
+            session_id=await handshake_session_id(data, mcp_session_id, token),
+            params=dict(ctx.params) if isinstance(ctx.params, Mapping) else {},
+            result=_to_jsonable(result),
+            extra={"session_id": mcp_session_id, "ctx": ctx},
+            timestamp=started,
+        )
+    except Exception as error:  # noqa: BLE001 - analytics must never break the handshake
+        log(f"Error: failed to capture $mcp_initialize - {error}")
 
 
 # --- registry plumbing ---------------------------------------------------------
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index 03b66392c..4e72e1de1 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -240,17 +240,89 @@ def _wrap_response(result: Any) -> Any:
     return serialized
 
 
+async def record_initialize(
+    data: MCPAnalyticsData,
+    *,
+    session_id: str,
+    params: Dict[str, Any],
+    result: Any,
+    extra: Optional[Dict[str, Any]],
+    timestamp: datetime,
+) -> None:
+    """Emit ``$mcp_initialize`` for an ``initialize`` the client sent.
+
+    The Python MCP SDK answers ``initialize`` itself (mcp 1.x inside
+    ``ServerSession``; mcp 2.x refuses a handler for it), so the seams that observe
+    it — ``Server.middleware`` on 2.x, the ASGI middleware on 1.x over HTTP — call
+    this inline in the handshake request once it has succeeded. ``result`` is the
+    server's reply where the seam can read it, else ``None``. Identify runs first
+    so the event is attributed on the pod that served the handshake, which on a
+    stateless fleet may never see this client again. The capture itself runs after,
+    in the background, as for every other event."""
+
+    def text(value: Any) -> Optional[str]:
+        return value if isinstance(value, str) and value else None
+
+    client_info = params.get("clientInfo")
+    client_info = client_info if isinstance(client_info, dict) else {}
+    agreed = result.get("protocolVersion") if isinstance(result, dict) else None
+    request = {"method": "initialize", "params": params}
+    await handle_identify(data, session_id, request, extra)
+    data.mark_session_initialized(session_id)
+    event: Dict[str, Any] = {
+        "event_type": MCPAnalyticsEventType.MCP_INITIALIZE,
+        "session_id": session_id,
+        "client_name": text(client_info.get("name")),
+        "client_version": text(client_info.get("version")),
+        "protocol_version": text(agreed) or text(params.get("protocolVersion")),
+        "parameters": request,
+        "response": result,
+        "timestamp": timestamp,
+    }
+    await _apply_event_properties(data, event, request, extra)
+    stamp_transport_identity(event, extra)
+    fire_and_forget(capture_event(data, event), data)
+
+
+# ASGI scope key a bound ``PostHogMcpStatelessSessionMiddleware`` sets to the
+# tracking state whose handshakes it captures, on each request it passes on.
+HANDSHAKE_OBSERVER_KEY = "posthog_mcp_handshake_observer"
+
+
+def _first_request_stands_in_for_initialize(
+    data: MCPAnalyticsData, session_source: str, extra: Optional[Dict[str, Any]]
+) -> bool:
+    """Whether this request has to stand in for an ``initialize`` nothing observed.
+
+    Only where no seam sees the real handshake: mcp 1.x over stdio (one client per
+    process, so its first request is as good as the handshake), and an mcp 1.x HTTP
+    request that did not pass a middleware bound to this server. Never for a
+    conversation-anchored session: it belongs to a chat, not to a handshake, and
+    synthesizing one there is how a single connection used to report two. So a
+    client whose first request already echoes a conversation reports no initialize
+    here."""
+    if data.handshake_observed_in_process:
+        return False
+    if session_source == "conversation":
+        return False
+    scope = getattr(get_request(extra), "scope", None)
+    return not (isinstance(scope, dict) and scope.get(HANDSHAKE_OBSERVER_KEY) is data)
+
+
 async def _maybe_emit_initialize(
     data: MCPAnalyticsData,
     session_id: str,
+    session_source: str,
     client_name: Optional[str],
     client_version: Optional[str],
     extra: Optional[Dict[str, Any]],
     protocol_version: Optional[str] = None,
 ) -> None:
-    """Lazily emit ``$mcp_initialize`` once per session. The Python MCP SDK handles
-    ``InitializeRequest`` inside the session layer (not ``request_handlers``), so we
-    synthesize the event from the first instrumented request that carries client info."""
+    """Emit ``$mcp_initialize`` once per session from its first request, where no
+    seam observes the real ``initialize`` (see
+    :func:`_first_request_stands_in_for_initialize`)."""
+    if not _first_request_stands_in_for_initialize(data, session_source, extra):
+        return
     if session_id in data.initialized_sessions:
         return
     data.mark_session_initialized(session_id)
@@ -373,8 +445,9 @@ async def prepare_request(
     protocol_version: Optional[str] = None,
     conversation_id: Optional[str] = None,
 ) -> str:
-    """Resolve the session id, run identify, then lazily emit initialize. Returns
-    the session id to stamp on the event for this request.
+    """Resolve the session id, run identify, then emit initialize if this request
+    has to stand in for an unobserved handshake. Returns the session id to stamp on
+    the event for this request.
 
     ``conversation_id`` is the agent's handle for this request, and when present
     it anchors the session (ADR-0004) so every event of the request — initialize
@@ -397,8 +470,8 @@ async def prepare_request(
     Identify runs *before* initialize so the resolved identity is already in the cache
     when ``capture_event`` builds the initialize event — otherwise the first
     ``$mcp_initialize`` is anonymous even when identify resolves on the same request.
-    (Still not byte-parity with the TS SDK, which wraps the real initialize handler;
-    the Python SDK handles initialize in the session layer, not ``request_handlers``.)
+    Where a seam observes the real handshake (:func:`record_initialize`), nothing
+    is synthesized here.
 
     A request that reached us over HTTP yet still resolved to this process's memory
     has nothing correlating it across pods, which on a stateless server means the
@@ -414,7 +487,13 @@ async def prepare_request(
         _warn_stateless_session_not_wired(data)
     await handle_identify(data, session_id, request, extra)
     await _maybe_emit_initialize(
-        data, session_id, client_name, client_version, extra, protocol_version
+        data,
+        session_id,
+        session_source,
+        client_name,
+        client_version,
+        extra,
+        protocol_version,
     )
     return session_id
 
diff --git a/posthog/mcp/_internal.py b/posthog/mcp/_internal.py
index 8da3cd8d0..44a1eeb48 100644
--- a/posthog/mcp/_internal.py
+++ b/posthog/mcp/_internal.py
@@ -107,6 +107,11 @@ class MCPAnalyticsData:
     # Bounded FIFO of sessions we've emitted $mcp_initialize for, so a long-lived
     # server can't accumulate one entry per session forever.
     initialized_sessions: "OrderedDict[str, None]" = field(default_factory=OrderedDict)
+    # True once mcp 2.x `Server.middleware` observes this server's real
+    # `initialize`, on every transport. On mcp 1.x an ASGI middleware bound to
+    # this server observes it over HTTP and marks each request it passes on;
+    # whatever neither covers falls back to the first request of the session.
+    handshake_observed_in_process: bool = False
     server_name: Optional[str] = None
     # Validated once during setup. Keep it separate from the caller-owned
     # options object so later option changes cannot alter event attribution.
@@ -130,6 +135,18 @@ def mark_session_initialized(self, session_id: str) -> None:
 )
 
 
+def tracking_key(server: Any) -> Any:
+    """The underlying low-level server for high-level wrappers (SDK 1.x FastMCP and
+    jlowin's fastmcp expose ``_mcp_server``; SDK 2.x MCPServer renamed it
+    ``_lowlevel_server``), else the server itself. Used as the tracking key so
+    instrumenting a wrapper and its underlying server resolve to one state instead
+    of two divergent ones (matching the TS SDK)."""
+    low_level = getattr(server, "_mcp_server", None) or getattr(
+        server, "_lowlevel_server", None
+    )
+    return low_level if low_level is not None else server
+
+
 def get_server_tracking_data(server: Any) -> Optional[MCPAnalyticsData]:
     return _server_tracking.get(server)
 
diff --git a/posthog/mcp/asgi.py b/posthog/mcp/asgi.py
index 4e742a143..a66b41113 100644
--- a/posthog/mcp/asgi.py
+++ b/posthog/mcp/asgi.py
@@ -12,6 +12,11 @@
 layer instead, with a pure-ASGI middleware that works for both a mounted FastMCP
 app and a custom ``PostHogMCP`` dispatcher, across every SDK routing path.
 
+The same blind spot hides the handshake from analytics on MCP SDK 1.x, so a
+middleware bound to an instrumented server also captures ``$mcp_initialize`` here,
+once per ``initialize``, in the session the response hands the client. (MCP SDK
+2.x exposes ``Server.middleware``, which ``instrument()`` uses instead.)
+
 On the ``instrument()`` path this is **wired up automatically**:
 ``instrument(server, ...)`` wraps the FastMCP server's app factories
 (``streamable_http_app()`` / ``sse_app()``, which ``mcp.run()`` also calls), so the
@@ -38,10 +43,15 @@
 
 import functools
 import json
-from typing import Any, Optional
+import weakref
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+from urllib.parse import parse_qs
 
+from ._instrumentation import HANDSHAKE_OBSERVER_KEY, record_initialize
+from ._internal import MCPAnalyticsData, get_server_tracking_data, tracking_key
 from .logger import log, warn
-from .session import new_session_id
+from .session import handshake_session_id, new_session_id
 from .session_token import (
     MCP_SESSION_HEADER,
     SessionTokenPayload,
@@ -73,16 +83,48 @@ class PostHogMcpStatelessSessionMiddleware:
     response header at ``initialize`` (when the client sent none) and decodes the
     replayed token on every request, exposing it via :func:`get_mcp_session`.
 
+    Pass the instrumented ``server`` to also capture ``$mcp_initialize`` from the
+    handshake itself on MCP SDK 1.x, which answers ``initialize`` outside anything
+    ``instrument()`` can wrap. ``instrument()`` does this for the apps it autowires;
+    add it yourself when you mount the middleware by hand on an instrumented server.
+    Leave it out for a custom ``PostHogMCP`` dispatcher, which captures its own
+    events.
+
     Fail-safe: any error while sniffing/minting is logged and the request passes
     through untouched -- analytics must never break the host."""
 
-    def __init__(self, app: Any) -> None:
+    def __init__(self, app: Any, server: Any = None) -> None:
         self.app = app
+        self._server: Optional[weakref.ReferenceType[Any]] = None
+        if server is not None:
+            try:
+                self._server = weakref.ref(tracking_key(server))
+            except TypeError as error:
+                log(f"PostHog MCP session middleware: cannot bind server= - {error}")
+
+    def _analytics(self) -> Optional[MCPAnalyticsData]:
+        """The bound server's tracking state, when this middleware is the one that
+        captures its handshakes: on mcp 2.x ``Server.middleware`` already does."""
+        try:
+            server = self._server() if self._server is not None else None
+            data = get_server_tracking_data(server) if server is not None else None
+        except TypeError:  # an unhashable server= can never be instrumented
+            return None
+        return None if data is None or data.handshake_observed_in_process else data
 
     async def __call__(self, scope: Any, receive: Any, send: Any) -> None:
         if scope.get("type") != "http":
             await self.app(scope, receive, send)
             return
+        # Tell the in-process fallback that this request's handshake is captured
+        # here. Two stacked middlewares see the same request; the outer one owns it.
+        # The SSE transport stays unmarked: its session is in a query parameter, so
+        # its first request captures the handshake, in the session its calls use.
+        observer = None
+        if HANDSHAKE_OBSERVER_KEY not in scope and not _is_sse(scope):
+            observer = self._analytics()
+            if observer is not None:
+                scope[HANDSHAKE_OBSERVER_KEY] = observer
 
         try:
             incoming_header = read_mcp_session_header(_headers_dict(scope))
@@ -98,6 +140,8 @@ async def __call__(self, scope: Any, receive: Any, send: Any) -> None:
 
         # Only POSTs carry JSON-RPC. Mint only when the client replayed no session
         # id at all -- if one is present (ours or a stateful transport's), leave it.
+        # Such a request is not read, so an initialize that reuses a session id is
+        # not captured here. Tool calls, which all carry one, stay unread.
         if scope.get("method") != "POST" or incoming_header is not None:
             await self.app(scope, receive, send)
             return
@@ -105,24 +149,51 @@ async def __call__(self, scope: Any, receive: Any, send: Any) -> None:
         # Guard the whole sniff+mint path: on any failure (a raising receive() or
         # adversarial body) the request passes through untouched, per the contract.
         token = None
+        initialize = None
         try:
             body, receive = await _buffer_body(receive)
-            token = _mint_token_if_initialize(body)
+            initialize = _parse_initialize(body)
+            if initialize is not None:
+                token = _mint_token(initialize)
         except Exception as error:  # noqa: BLE001
             log(f"PostHog MCP session middleware: mint failed - {error}")
 
-        if token is None:
+        if initialize is None:
             await self.app(scope, receive, send)
             return
 
-        scope[_SCOPE_KEY] = decode_session_id(token)
-        await self.app(scope, receive, _sending_session_header(send, token))
+        started = datetime.now(timezone.utc)
+        if observer is not None:
+            send = _InitializeResponse(
+                send,
+                functools.partial(
+                    _record_initialize, observer, initialize, scope, started
+                ),
+            )
+        if token is not None:
+            scope[_SCOPE_KEY] = decode_session_id(token)
+            send = _sending_session_header(send, token)
+
+        await self.app(scope, receive, send)
+
+
+def _is_sse(scope: Any) -> bool:
+    """The deprecated SSE transport, which keys its session on ``?session_id=``."""
+    try:
+        query = parse_qs((scope.get("query_string") or b"").decode("latin-1"))
+    except Exception:  # noqa: BLE001
+        return False
+    return "session_id" in query
 
 
 def _headers_dict(scope: Any) -> dict[str, str]:
     """ASGI raw headers (list of (bytes, bytes)) -> a lowercased str dict."""
+    return _decode_headers(scope.get("headers") or [])
+
+
+def _decode_headers(raw: Any) -> dict[str, str]:
     result: dict[str, str] = {}
-    for key, value in scope.get("headers") or []:
+    for key, value in raw:
         try:
             result[key.decode("latin-1").lower()] = value.decode("latin-1")
         except Exception:  # noqa: BLE001
@@ -143,10 +214,13 @@ async def _buffer_body(receive: Any) -> tuple[bytes, Any]:
     total = 0
     complete = False
     overflow = False
+    # A non-body message (e.g. http.disconnect) ends the read early. It is kept
+    # and handed to the app after the prefix, so the app sees the disconnect.
+    held: Optional[dict[str, Any]] = None
     while True:
         message = await receive()
         if message.get("type") != "http.request":
-            # A non-body message (e.g. http.disconnect); stop with what we have.
+            held = message
             break
         chunks.append(message.get("body", b"") or b"")
         total += len(chunks[-1])
@@ -162,11 +236,14 @@ async def _buffer_body(receive: Any) -> tuple[bytes, Any]:
 
     async def replay() -> dict[str, Any]:
         # Replay the buffered prefix once; if we stopped early, flag more_body so
-        # the app keeps pulling the rest straight from the original transport.
-        nonlocal replayed
+        # the app keeps reading: the held message, then the original transport.
+        nonlocal replayed, held
         if not replayed:
             replayed = True
-            return {"type": "http.request", "body": buffered, "more_body": overflow}
+            return {"type": "http.request", "body": buffered, "more_body": not complete}
+        if held is not None:
+            message, held = held, None
+            return message
         return await receive()
 
     # Only sniff (parse for `initialize`) when we captured the whole small body.
@@ -174,10 +251,9 @@ async def replay() -> dict[str, Any]:
     return sniff, replay
 
 
-def _mint_token_if_initialize(body: bytes) -> Optional[str]:
-    """If ``body`` is an ``initialize`` JSON-RPC request, mint and return a token
-    string carrying a fresh session id + the client's self-reported identity.
-    Returns ``None`` for anything else (never raises)."""
+def _parse_initialize(body: bytes) -> Optional[Dict[str, Any]]:
+    """The JSON-RPC message in ``body`` if it is an ``initialize`` request, else
+    ``None`` (never raises)."""
     if not body:
         return None
     try:
@@ -188,10 +264,13 @@ def _mint_token_if_initialize(body: bytes) -> Optional[str]:
         return None
     if not isinstance(message, dict) or message.get("method") != "initialize":
         return None
-    params = message.get("params")
-    params = params if isinstance(params, dict) else {}
-    client_info = params.get("clientInfo")
-    client_info = client_info if isinstance(client_info, dict) else {}
+    return message
+
+
+def _mint_token(message: Dict[str, Any]) -> Optional[str]:
+    """Mint a token carrying a fresh session id + the client's self-reported
+    identity from an ``initialize`` message. Returns ``None`` on failure."""
+    params, client_info = _initialize_params(message)
     try:
         return encode_session_id(
             SessionTokenPayload(
@@ -206,6 +285,82 @@ def _mint_token_if_initialize(body: bytes) -> Optional[str]:
         return None
 
 
+def _initialize_params(
+    message: Dict[str, Any],
+) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    params = message.get("params")
+    params = params if isinstance(params, dict) else {}
+    client_info = params.get("clientInfo")
+    return params, client_info if isinstance(client_info, dict) else {}
+
+
+class _InitializeResponse:
+    """A ``send`` that records the handshake when the ``initialize`` response
+    starts, then passes the response on. The app calls it from inside its own
+    request context, so an auth middleware's user is still set for ``identify``.
+    The start carries the status and the ``Mcp-Session-Id`` the client will send
+    back (whichever of the transport or the mint set it). The body is not read."""
+
+    def __init__(self, send: Any, record: Any) -> None:
+        self._send = send
+        self._record = record
+
+    async def __call__(self, message: Dict[str, Any]) -> None:
+        if message.get("type") == "http.response.start" and self._record is not None:
+            record, self._record = self._record, None
+            headers = _decode_headers(message.get("headers") or [])
+            await record(
+                message.get("status"), headers.get(MCP_SESSION_HEADER.lower()) or None
+            )
+        await self._send(message)
+
+
+class _InitializeContext:
+    """``extra["ctx"]`` for callbacks run on an ``initialize`` observed here.
+
+    MCP SDK 1.x answers ``initialize`` inside its session layer, outside any request
+    context, so there is no SDK context object to hand over. This carries only the
+    HTTP request, which is what :func:`~posthog.mcp.get_request_headers` reads."""
+
+    def __init__(self, request: Any) -> None:
+        self.request = request
+
+
+async def _record_initialize(
+    data: MCPAnalyticsData,
+    message: Dict[str, Any],
+    scope: Any,
+    started: datetime,
+    status: Optional[int],
+    session_header: Optional[str],
+) -> None:
+    """Emit ``$mcp_initialize`` for a handshake the app answered, in the session the
+    client's later requests resolve to: the ``Mcp-Session-Id`` they send back (a
+    stateful transport's id or our token), or this process's own session when the
+    response carried none. The body is not read, so the
+    event carries the protocol version the client asked for."""
+    try:
+        if status is None or not 200 <= status < 300:
+            return
+        from starlette.requests import Request
+
+        header = session_header
+        await record_initialize(
+            data,
+            session_id=await handshake_session_id(
+                data, header, decode_session_id(header)
+            ),
+            params=_initialize_params(message)[0],
+            result=None,
+            extra={"session_id": header, "ctx": _InitializeContext(Request(scope))},
+            timestamp=started,
+        )
+    except Exception as error:  # noqa: BLE001 - analytics must never break the host
+        log(
+            f"PostHog MCP session middleware: failed to capture $mcp_initialize - {error}"
+        )
+
+
 def _sending_session_header(send: Any, token: str) -> Any:
     """Wrap ``send`` so the outgoing response start carries ``Mcp-Session-Id: token``
     -- but only if the app/transport didn't already set one (never clobber a
@@ -251,7 +406,7 @@ def autowire_stateless_mint(server: Any) -> None:
         if not callable(original) or getattr(original, _AUTOWIRED, False):
             continue
         try:
-            setattr(server, attr, _wrap_app_factory(original))
+            setattr(server, attr, _wrap_app_factory(original, server))
         except Exception as error:  # noqa: BLE001 - never let wiring break instrument()
             log(f"PostHog MCP: could not auto-wire stateless mint on {attr} - {error}")
 
@@ -312,7 +467,7 @@ def _app_already_wrapped(app: Any) -> bool:
     return False
 
 
-def _wrap_app_factory(original: Any) -> Any:
+def _wrap_app_factory(original: Any, server: Any = None) -> Any:
     @functools.wraps(original)
     def factory(*args: Any, **kwargs: Any) -> Any:
         app = original(*args, **kwargs)
@@ -320,10 +475,10 @@ def factory(*args: Any, **kwargs: Any) -> Any:
             return app
         add_middleware = getattr(app, "add_middleware", None)
         if callable(add_middleware):
-            add_middleware(PostHogMcpStatelessSessionMiddleware)
+            add_middleware(PostHogMcpStatelessSessionMiddleware, server=server)
             return app
         # Not a Starlette app -- wrap as raw ASGI so minting still happens.
-        return PostHogMcpStatelessSessionMiddleware(app)
+        return PostHogMcpStatelessSessionMiddleware(app, server=server)
 
     setattr(factory, _AUTOWIRED, True)
     return factory
diff --git a/posthog/mcp/session.py b/posthog/mcp/session.py
index dc59f51fb..4da6a6273 100644
--- a/posthog/mcp/session.py
+++ b/posthog/mcp/session.py
@@ -60,6 +60,25 @@ async def resolve_session_id(
     return session_id
 
 
+async def handshake_session_id(
+    data: MCPAnalyticsData,
+    mcp_session_id: Optional[str],
+    token: Optional[SessionTokenPayload],
+) -> str:
+    """The session an ``initialize`` belongs to: the one the client's later requests
+    resolve to through :func:`resolve_session_id_with_source`.
+
+    A token or a transport session id gives it directly, so this leaves the server's
+    shared session alone. One server serves many clients, and a handshake must not
+    move the session that ``McpAnalytics.capture()`` reads. Without either, the
+    session is this process's own, which only the resolver can hand out."""
+    if token is not None:
+        return token.session_id
+    if mcp_session_id:
+        return derive_session_id_from_mcp_session(mcp_session_id)
+    return await resolve_session_id(data, None)
+
+
 async def resolve_session_id_with_source(
     data: MCPAnalyticsData,
     mcp_session_id: Optional[str],
diff --git a/posthog/test/mcp/test_initialize_handshake.py b/posthog/test/mcp/test_initialize_handshake.py
new file mode 100644
index 000000000..022235fa1
--- /dev/null
+++ b/posthog/test/mcp/test_initialize_handshake.py
@@ -0,0 +1,990 @@
+"""``$mcp_initialize`` is one event per ``initialize`` the client actually sent.
+
+The spec (sdk-specs ``mcp-analytics``) allows ``$mcp_initialize`` only for a legacy
+``initialize`` request, and never without one. Python cannot wrap ``initialize``
+the way posthog-js does — mcp 1.x answers it inside ``ServerSession`` and mcp 2.x
+refuses a handler for it — so these tests drive a real streamable-HTTP app over
+raw JSON-RPC and count what comes out. Written once, collected under both SDK
+majors; the version-specific code is :func:`make_pod`, which builds each server
+shape a host might run.
+
+The shapes are the ones agents produce in the field: a client that reconnects
+before every few calls (Codex, hosted connectors), a probe that handshakes and
+leaves, and a stateless fleet behind a load balancer with no stickiness, where
+one handshake's requests land on several pods.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import Any, Dict, List, Optional
+
+import httpx
+import pytest
+
+from posthog.mcp import (
+    MCPAnalyticsOptions,
+    UserIdentity,
+    decode_session_id,
+    get_request_headers,
+    instrument,
+)
+from posthog.test.mcp._helpers import (
+    MCP_MAJOR,
+    FakeClient,
+    events_named as _events,
+    flush_background as _flush,
+)
+
+PROTOCOL_VERSION = "2025-06-18"
+BASE_HEADERS = {
+    "content-type": "application/json",
+    "accept": "application/json, text/event-stream",
+}
+
+
+#: The server shapes a host builds, each served the way that shape is served:
+#: the official SDK's high-level server, standalone ``fastmcp`` (jlowin's 2.x/3.x
+#: on mcp 1.x, 4.x on mcp 2.x), and a low-level ``Server``.
+KINDS = ["official", "fastmcp", "lowlevel"]
+
+
+def make_pod(
+    client: FakeClient,
+    *,
+    kind: str = "official",
+    stateless: bool = True,
+    options: Optional[MCPAnalyticsOptions] = None,
+    bind: bool = True,
+):
+    """One instrumented server of ``kind``, as ``(asgi_app, lifespan, server)``.
+
+    ``bind`` only matters for an mcp 1.x low-level server: nothing autowires it,
+    so the middleware is mounted by hand, with or without ``server=``."""
+    options = options or MCPAnalyticsOptions(enable_conversation_id=False)
+    if kind == "fastmcp":
+        return _fastmcp_pod(client, options, stateless)
+    if kind == "lowlevel":
+        return _lowlevel_pod(client, options, stateless, bind)
+    if MCP_MAJOR < 2:
+        from mcp.server.fastmcp import FastMCP
+        from mcp.server.transport_security import TransportSecuritySettings
+
+        server = FastMCP(
+            "handshake",
+            stateless_http=stateless,
+            json_response=True,
+            transport_security=TransportSecuritySettings(
+                enable_dns_rebinding_protection=False
+            ),
+        )
+    else:
+        from mcp.server.mcpserver import MCPServer
+
+        server = MCPServer("handshake")
+
+    @server.tool()
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    instrument(server, client, options)
+    if MCP_MAJOR < 2:
+        app = server.streamable_http_app()
+    else:
+        app = server.streamable_http_app(json_response=True, stateless_http=stateless)
+    return app, server.session_manager.run(), server
+
+
+def _fastmcp_pod(client, options, stateless):
+    fastmcp = pytest.importorskip("fastmcp")
+
+    server = fastmcp.FastMCP("handshake")
+
+    @server.tool()
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    instrument(server, client, options)
+    app = server.http_app(json_response=True, stateless_http=stateless)
+    return app, app.router.lifespan_context(app), server
+
+
+def _lowlevel_pod(client, options, stateless, bind):
+    import mcp.types as mcp_types
+    from mcp.server.lowlevel import Server
+
+    schema = {
+        "type": "object",
+        "properties": {"a": {"type": "integer"}, "b": {"type": "integer"}},
+    }
+
+    def total(arguments):
+        return str((arguments or {}).get("a", 0) + (arguments or {}).get("b", 0))
+
+    if MCP_MAJOR >= 2:
+
+        async def on_list_tools(ctx, params):
+            return mcp_types.ListToolsResult(
+                tools=[mcp_types.Tool(name="add", input_schema=schema)]
+            )
+
+        async def on_call_tool(ctx, params):
+            return mcp_types.CallToolResult(
+                content=[
+                    mcp_types.TextContent(type="text", text=total(params.arguments))
+                ]
+            )
+
+        server = Server(
+            "handshake", on_list_tools=on_list_tools, on_call_tool=on_call_tool
+        )
+        instrument(server, client, options)
+        app = server.streamable_http_app(json_response=True, stateless_http=stateless)
+        return app, server.session_manager.run(), server
+
+    from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
+    from posthog.mcp import PostHogMcpStatelessSessionMiddleware
+
+    server = Server("handshake")
+
+    @server.list_tools()
+    async def list_tools_handler():
+        return [mcp_types.Tool(name="add", inputSchema=schema)]
+
+    @server.call_tool()
+    async def call_tool_handler(name, arguments):
+        return [mcp_types.TextContent(type="text", text=total(arguments))]
+
+    instrument(server, client, options)
+    manager = StreamableHTTPSessionManager(
+        app=server, stateless=stateless, json_response=True
+    )
+    app = (
+        PostHogMcpStatelessSessionMiddleware(manager.handle_request, server=server)
+        if bind
+        else PostHogMcpStatelessSessionMiddleware(manager.handle_request)
+    )
+    return app, manager.run(), server
+
+
+@asynccontextmanager
+async def fleet(client: FakeClient, pods: int = 1, **pod_options: Any):
+    """``pods`` independently instrumented servers, each a live HTTP surface. Every
+    pod has its own tracking state, exactly like separate processes behind a
+    load balancer."""
+    async with AsyncExitStack() as stack:
+        surfaces: List[httpx.AsyncClient] = []
+        for _ in range(pods):
+            app, lifespan, _ = make_pod(client, **pod_options)
+            await stack.enter_async_context(lifespan)
+            surfaces.append(
+                await stack.enter_async_context(
+                    httpx.AsyncClient(
+                        transport=httpx.ASGITransport(app=app),
+                        base_url="http://127.0.0.1:8000",
+                    )
+                )
+            )
+        yield RoundRobin(surfaces)
+
+
+class RoundRobin:
+    """A load balancer with no stickiness: each request goes to the next pod."""
+
+    def __init__(self, pods: List[httpx.AsyncClient]):
+        self.pods = pods
+        self.turn = 0
+
+    async def post(
+        self, body: Dict[str, Any], headers: Dict[str, str]
+    ) -> httpx.Response:
+        pod = self.pods[self.turn % len(self.pods)]
+        self.turn += 1
+        return await pod.post("/mcp", json=body, headers=headers)
+
+
+def rpc(method: str, params: Dict[str, Any], request_id: Optional[int] = 1):
+    body: Dict[str, Any] = {"jsonrpc": "2.0", "method": method, "params": params}
+    if request_id is not None:
+        body["id"] = request_id
+    return body
+
+
+def initialize_params(client_name: str) -> Dict[str, Any]:
+    return {
+        "protocolVersion": PROTOCOL_VERSION,
+        "capabilities": {},
+        "clientInfo": {"name": client_name, "version": "0.50.0"},
+    }
+
+
+async def handshake(
+    lb: RoundRobin,
+    *,
+    client_name: str = "codex-mcp-client",
+    extra_headers: Optional[Dict[str, str]] = None,
+    send_initialized: bool = True,
+):
+    """``initialize`` then ``notifications/initialized``, as every MCP client
+    connects. Returns the headers the client replays afterwards and the
+    negotiated protocol version."""
+    headers = {**BASE_HEADERS, **(extra_headers or {})}
+    response = await lb.post(rpc("initialize", initialize_params(client_name)), headers)
+    assert response.status_code == 200, response.text
+    negotiated = response.json()["result"]["protocolVersion"]
+    replay = {**headers, "mcp-protocol-version": negotiated}
+    session_header = response.headers.get("mcp-session-id")
+    if session_header:
+        replay["mcp-session-id"] = session_header
+    if send_initialized:
+        await lb.post(rpc("notifications/initialized", {}, None), replay)
+    return replay, negotiated
+
+
+async def call_add(
+    lb: RoundRobin, headers: Dict[str, str], request_id: int = 3, **extra: Any
+):
+    """``tools/call add``. ``extra`` adds arguments or params (``_meta``)."""
+    meta = {"_meta": extra.pop("_meta")} if "_meta" in extra else {}
+    arguments = {"a": 2, "b": 3, "context": "adding", **extra}
+    response = await lb.post(
+        rpc("tools/call", {"name": "add", "arguments": arguments, **meta}, request_id),
+        headers,
+    )
+    assert response.status_code == 200, response.text
+    return response
+
+
+async def list_tools(lb: RoundRobin, headers: Dict[str, str]):
+    response = await lb.post(rpc("tools/list", {}, 2), headers)
+    assert response.status_code == 200, response.text
+    return response
+
+
+# --- one event per handshake ------------------------------------------------------
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_one_initialize_per_handshake_across_stateless_pods(kind):
+    # The overcount this file exists for: dedupe used to be per process, so every
+    # pod a session touched emitted its own $mcp_initialize.
+    client = FakeClient()
+    async with fleet(client, pods=2, kind=kind) as lb:
+        headers, negotiated = await handshake(lb)
+        await list_tools(lb, headers)
+        await call_add(lb, headers, 3)
+        await call_add(lb, headers, 4)
+        await call_add(lb, headers, 5)
+    await _flush()
+
+    inits = _events(client, "$mcp_initialize")
+    assert len(inits) == 1
+    calls = _events(client, "$mcp_tool_call")
+    assert len(calls) == 3
+    sessions = {c["properties"]["$session_id"] for c in calls}
+    assert sessions == {inits[0]["properties"]["$session_id"]}
+    props = inits[0]["properties"]
+    assert props["$mcp_client_name"] == "codex-mcp-client"
+    assert props["$mcp_client_version"] == "0.50.0"
+    assert props["$mcp_protocol_version"] == negotiated
+    assert (
+        props["$mcp_parameters"]["params"]["clientInfo"]["name"] == "codex-mcp-client"
+    )
+    assert props["$mcp_duration_ms"] >= 0
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_each_reconnect_is_one_initialize(kind):
+    client = FakeClient()
+    async with fleet(client, pods=2, kind=kind) as lb:
+        for _ in range(3):
+            headers, _ = await handshake(lb)
+            await list_tools(lb, headers)
+            await call_add(lb, headers)
+            await call_add(lb, headers, 4)
+    await _flush()
+
+    inits = _events(client, "$mcp_initialize")
+    assert len(inits) == 3
+    assert len({e["properties"]["$session_id"] for e in inits}) == 3
+    assert len(_events(client, "$mcp_tool_call")) == 6
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_a_bare_handshake_is_counted(kind):
+    # Probes and health checkers connect and leave. There is no later request to
+    # hang a synthesized event on, which used to make them invisible.
+    client = FakeClient()
+    async with fleet(client, kind=kind) as lb:
+        await handshake(lb, send_initialized=False)
+        await handshake(lb)
+    await _flush()
+
+    assert len(_events(client, "$mcp_initialize")) == 2
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_initialize_session_matches_a_stateful_transport(kind):
+    # On a stateful server the transport assigns Mcp-Session-Id in the initialize
+    # response; the event must land in the session every later request resolves to.
+    client = FakeClient()
+    async with fleet(client, stateless=False, kind=kind) as lb:
+        headers, _ = await handshake(lb)
+        await call_add(lb, headers)
+        await call_add(lb, headers, 4)
+    await _flush()
+
+    inits = _events(client, "$mcp_initialize")
+    assert len(inits) == 1
+    calls = _events(client, "$mcp_tool_call")
+    assert {c["properties"]["$session_id"] for c in calls} == {
+        inits[0]["properties"]["$session_id"]
+    }
+
+
+async def test_initialize_is_attributed_on_the_pod_that_served_it():
+    def identify(request, extra):
+        headers = get_request_headers(extra) or {}
+        token = headers.get("authorization", "")
+        return (
+            UserIdentity(distinct_id=token.removeprefix("Bearer ")) if token else None
+        )
+
+    client = FakeClient()
+    options = MCPAnalyticsOptions(enable_conversation_id=False, identify=identify)
+    async with fleet(client, pods=2, options=options) as lb:
+        headers, _ = await handshake(
+            lb, extra_headers={"authorization": "Bearer user_alice"}
+        )
+        await call_add(lb, headers)
+    await _flush()
+
+    (init,) = _events(client, "$mcp_initialize")
+    assert init["distinct_id"] == "user_alice"
+    assert init["properties"]["$mcp_client_user_agent"]
+
+
+@pytest.mark.skipif(
+    MCP_MAJOR < 2,
+    reason="mcp 1.x reads only the response head, and a JSON-RPC error is an HTTP 200",
+)
+async def test_a_failed_initialize_is_not_captured():
+    client = FakeClient()
+    async with fleet(client) as lb:
+        response = await lb.post(rpc("initialize", {"capabilities": {}}), BASE_HEADERS)
+    await _flush()
+
+    assert "error" in response.json()
+    assert _events(client, "$mcp_initialize") == []
+
+
+async def test_an_echoed_conversation_does_not_initialize_again():
+    # ADR-0004 anchors echoed calls to the conversation's session. That session
+    # never sent an initialize, so it gets no $mcp_initialize of its own.
+    from posthog.mcp._conversation_id import _uuid7
+
+    conversation_id = _uuid7()
+    client = FakeClient()
+    options = MCPAnalyticsOptions(enable_conversation_id=True)
+    async with fleet(client, pods=2, options=options) as lb:
+        headers, _ = await handshake(lb)
+        for request_id in (3, 4, 5):
+            await call_add(lb, headers, request_id, conversation_id=conversation_id)
+    await _flush()
+
+    calls = _events(client, "$mcp_tool_call")
+    assert len(calls) == 3
+    assert {c["properties"]["$mcp_conversation_id"] for c in calls} == {conversation_id}
+    assert len(_events(client, "$mcp_initialize")) == 1
+
+
+# --- the 2026-07-28 revision has no initialize -------------------------------------
+
+
+@pytest.mark.skipif(MCP_MAJOR < 2, reason="mcp 1.x cannot serve 2026-07-28")
+async def test_modern_era_requests_emit_no_initialize():
+    from posthog.test.mcp._helpers_v2 import modern_headers, modern_meta
+
+    client = FakeClient()
+    headers = {**BASE_HEADERS, **modern_headers("tools/call", "add")}
+    async with fleet(client, pods=2) as lb:
+        for request_id in (1, 2, 3):
+            await call_add(lb, headers, request_id, _meta=modern_meta())
+    await _flush()
+
+    assert len(_events(client, "$mcp_tool_call")) == 3
+    assert _events(client, "$mcp_initialize") == []
+
+
+# --- mcp 1.x low-level server, middleware mounted by hand --------------------------
+
+
+@pytest.mark.skipif(MCP_MAJOR >= 2, reason="mcp 2.x observes initialize in-process")
+async def test_an_unbound_middleware_keeps_the_first_request_fallback():
+    # Without server= the middleware cannot reach the tracking state, so the first
+    # request of the session on each pod still stands in for the handshake: the
+    # pre-existing behaviour, kept so a hand-mounted middleware never goes dark.
+    client = FakeClient()
+    async with fleet(client, pods=2, kind="lowlevel", bind=False) as lb:
+        headers, _ = await handshake(lb)
+        await call_add(lb, headers)
+        await call_add(lb, headers, 4)
+    await _flush()
+
+    assert len(_events(client, "$mcp_initialize")) == 2
+
+
+# --- stdio: a real server process, driven over its pipes ---------------------------
+
+_STDIO_SERVER = """
+import importlib.metadata
+import json
+import os
+
+from posthog.mcp import MCPAnalyticsOptions, instrument
+
+
+class FileClient:
+    # Appends each capture to a file the test reads, one JSON line per event.
+    def capture(self, event, distinct_id=None, properties=None, **kwargs):
+        with open(os.environ["EVENTS_FILE"], "a") as sink:
+            sink.write(json.dumps({"event": event, "properties": properties or {}}, default=str) + "\\n")
+
+
+if int(importlib.metadata.version("mcp").split(".")[0]) < 2:
+    from mcp.server.fastmcp import FastMCP as Server
+else:
+    from mcp.server.mcpserver import MCPServer as Server
+
+server = Server("stdio-handshake")
+
+
+@server.tool()
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+instrument(server, FileClient(), MCPAnalyticsOptions(enable_conversation_id=False))
+server.run()
+"""
+
+
+class StdioServer:
+    """The instrumented server as a child process on stdio, the way a desktop client
+    launches it: newline-delimited JSON-RPC on stdin/stdout."""
+
+    def __init__(self, process, events_file):
+        self.process = process
+        self.events_file = events_file
+
+    async def send(self, method, params, request_id=None):
+        self.process.stdin.write(
+            (json.dumps(rpc(method, params, request_id)) + "\n").encode()
+        )
+        await self.process.stdin.drain()
+        if request_id is None:
+            return None
+        line = await asyncio.wait_for(self.process.stdout.readline(), timeout=20)
+        return json.loads(line)
+
+    async def events(self, name, count):
+        """Captures are fire-and-forget in the child: wait for ``count`` of them,
+        then a moment more for any that would make it one too many."""
+        for _ in range(100):
+            if self.events_file.exists():
+                lines = self.events_file.read_text().splitlines()
+                found = [e for e in map(json.loads, lines) if e["event"] == name]
+                if len(found) >= count:
+                    break
+            await asyncio.sleep(0.05)
+        await asyncio.sleep(0.2)
+        lines = self.events_file.read_text().splitlines()
+        return [e for e in map(json.loads, lines) if e["event"] == name]
+
+
+@asynccontextmanager
+async def stdio_server(tmp_path):
+    script = tmp_path / "stdio_server.py"
+    script.write_text(_STDIO_SERVER)
+    events_file = tmp_path / "events.jsonl"
+    process = await asyncio.create_subprocess_exec(
+        sys.executable,
+        str(script),
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.DEVNULL,
+        env={**os.environ, "EVENTS_FILE": str(events_file)},
+        cwd=str(tmp_path),
+    )
+    try:
+        yield StdioServer(process, events_file)
+    finally:
+        if process.stdin and not process.stdin.is_closing():
+            process.stdin.close()
+        try:
+            await asyncio.wait_for(process.wait(), timeout=10)
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.wait()
+
+
+async def test_stdio_handshake_then_calls(tmp_path):
+    async with stdio_server(tmp_path) as server:
+        reply = await server.send("initialize", initialize_params("claude-desktop"), 1)
+        assert "result" in reply, reply
+        await server.send("notifications/initialized", {})
+        await server.send("tools/list", {}, 2)
+        for request_id in (3, 4):
+            reply = await server.send(
+                "tools/call",
+                {"name": "add", "arguments": {"a": 1, "b": 2, "context": "stdio"}},
+                request_id,
+            )
+            assert reply["result"]["isError"] is False, reply
+        calls = await server.events("$mcp_tool_call", 2)
+        inits = await server.events("$mcp_initialize", 1)
+
+    assert len(calls) == 2
+    assert len(inits) == 1
+    props = inits[0]["properties"]
+    assert props["$mcp_client_name"] == "claude-desktop"
+    assert {c["properties"]["$session_id"] for c in calls} == {props["$session_id"]}
+
+
+@pytest.mark.skipif(MCP_MAJOR < 2, reason="mcp 1.x stdio has no handshake seam")
+async def test_stdio_bare_handshake_is_counted(tmp_path):
+    async with stdio_server(tmp_path) as server:
+        reply = await server.send("initialize", initialize_params("claude-desktop"), 1)
+        assert "result" in reply, reply
+        inits = await server.events("$mcp_initialize", 1)
+
+    assert len(inits) == 1
+    assert (
+        inits[0]["properties"]["$mcp_protocol_version"]
+        == reply["result"]["protocolVersion"]
+    )
+
+
+# --- custom dispatcher: PostHogMCP behind an unbound middleware ---------------------
+
+
+def make_dispatcher(posthog_mcp):
+    """A hand-rolled JSON-RPC endpoint, the shape ``PostHogMCP`` exists for: the host
+    answers ``initialize`` itself and captures it through the manual API."""
+    from starlette.applications import Starlette
+    from starlette.responses import JSONResponse, Response
+    from starlette.routing import Route
+
+    from posthog.mcp import get_mcp_session
+
+    async def endpoint(request):
+        message = await request.json()
+        if "id" not in message:  # a notification: accepted, nothing to answer
+            return Response(status_code=202)
+        result: Dict[str, Any] = {"tools": []}
+        if message["method"] == "initialize":
+            session = get_mcp_session(request)
+            posthog_mcp.capture_initialize(
+                client_name=message["params"]["clientInfo"]["name"],
+                session_id=session.session_id if session else None,
+            )
+            result = {
+                "protocolVersion": message["params"]["protocolVersion"],
+                "capabilities": {},
+                "serverInfo": {"name": "dispatcher", "version": "1.0.0"},
+            }
+        return JSONResponse({"jsonrpc": "2.0", "id": message["id"], "result": result})
+
+    return Starlette(routes=[Route("/mcp", endpoint, methods=["POST"])])
+
+
+async def test_a_posthogmcp_dispatcher_reports_only_its_own_initialize():
+    from posthog.mcp import PostHogMCP, PostHogMcpStatelessSessionMiddleware
+
+    captured: List[Dict[str, Any]] = []
+
+    def keep(event):
+        captured.append(event)
+        return event
+
+    posthog_mcp = PostHogMCP("phc_test", send=False, before_send=keep)
+    # An instrumented server in the same process: an unbound middleware must never
+    # attach the dispatcher's handshakes to it.
+    bystander = FakeClient()
+    make_pod(bystander)
+
+    app = PostHogMcpStatelessSessionMiddleware(make_dispatcher(posthog_mcp))
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+    ) as http:
+        lb = RoundRobin([http])
+        headers, _ = await handshake(lb, client_name="dispatcher-client")
+        await list_tools(lb, headers)
+    await _flush()
+
+    inits = [e for e in captured if e["event"] == "$mcp_initialize"]
+    assert len(inits) == 1
+    assert inits[0]["properties"]["$mcp_client_name"] == "dispatcher-client"
+    # The session the host read back from the minted token, not a second one.
+    token = decode_session_id(headers["mcp-session-id"])
+    assert token is not None
+    assert inits[0]["properties"]["$session_id"] == token.session_id
+    assert bystander.events == []
+
+
+# --- the deprecated SSE transport: session in a query parameter ---------------------
+
+
+@asynccontextmanager
+async def sse_server(client: FakeClient):
+    """An instrumented server's ``sse_app()`` on a real port. The SSE transport keeps
+    its session in the ``session_id`` query parameter of ``/messages/``, not in a
+    header, and answers each POST with 202 and the reply on the event stream."""
+    import uvicorn
+
+    if MCP_MAJOR < 2:
+        from mcp.server.fastmcp import FastMCP
+        from mcp.server.transport_security import TransportSecuritySettings
+
+        server = FastMCP(
+            "handshake",
+            transport_security=TransportSecuritySettings(
+                enable_dns_rebinding_protection=False
+            ),
+        )
+    else:
+        from mcp.server.mcpserver import MCPServer
+
+        server = MCPServer("handshake")
+
+    @server.tool()
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
+    config = uvicorn.Config(server.sse_app(), port=0, log_level="error", ws="none")
+    http_server = uvicorn.Server(config)
+    serving = asyncio.create_task(http_server.serve())
+    while not http_server.started:
+        await asyncio.sleep(0.01)
+    port = http_server.servers[0].sockets[0].getsockname()[1]
+    try:
+        yield f"http://127.0.0.1:{port}"
+    finally:
+        http_server.should_exit = True
+        await asyncio.wait_for(serving, timeout=10)
+
+
+async def test_sse_transport_handshake_then_calls():
+    client = FakeClient()
+    async with sse_server(client) as url:
+        async with httpx.AsyncClient(base_url=url, timeout=20) as http:
+            async with http.stream("GET", "/sse") as stream:
+                lines = stream.aiter_lines()
+
+                async def next_data() -> str:
+                    async for line in lines:
+                        if line.startswith("data:"):
+                            return line[len("data:") :].strip()
+                    raise AssertionError("the event stream closed")
+
+                endpoint = await next_data()
+
+                async def send(method, params, request_id=None):
+                    response = await http.post(
+                        endpoint, json=rpc(method, params, request_id)
+                    )
+                    assert response.status_code == 202, response.text
+                    return json.loads(await next_data()) if request_id else None
+
+                await send("initialize", initialize_params("sse-client"), 1)
+                await send("notifications/initialized", {})
+                await send("tools/list", {}, 2)
+                for request_id in (3, 4):
+                    arguments = {"a": 1, "b": 2, "context": "sse"}
+                    reply = await send(
+                        "tools/call",
+                        {"name": "add", "arguments": arguments},
+                        request_id,
+                    )
+                    assert reply["result"]["isError"] is False, reply
+    await _flush()
+
+    (init,) = _events(client, "$mcp_initialize")
+    calls = _events(client, "$mcp_tool_call")
+    assert len(calls) == 2
+    assert {c["properties"]["$session_id"] for c in calls} == {
+        init["properties"]["$session_id"]
+    }
+
+
+# --- the middleware is per request and fail-safe -----------------------------------
+
+
+@pytest.mark.skipif(MCP_MAJOR >= 2, reason="mcp 2.x has no first-request fallback")
+async def test_a_route_without_the_middleware_keeps_the_fallback():
+    # One process, one server, two routes: the autowired app with the bound
+    # middleware, and the session manager mounted by hand without it. Each route
+    # reports its own handshakes, once.
+    client = FakeClient()
+    app, lifespan, server = make_pod(client)
+    async with lifespan:
+        for surface in (app, server.session_manager.handle_request):
+            async with httpx.AsyncClient(
+                transport=httpx.ASGITransport(app=surface),
+                base_url="http://127.0.0.1:8000",
+            ) as http:
+                lb = RoundRobin([http])
+                headers, _ = await handshake(lb)
+                await call_add(lb, headers)
+                await call_add(lb, headers, 4)
+    await _flush()
+
+    inits = _events(client, "$mcp_initialize")
+    assert len(inits) == 2
+    calls = _events(client, "$mcp_tool_call")
+    assert {c["properties"]["$session_id"] for c in calls} == {
+        e["properties"]["$session_id"] for e in inits
+    }
+
+
+async def test_a_handshake_leaves_the_shared_session_alone():
+    # McpAnalytics.capture() reads the server's shared session. A handshake that
+    # carries its own session (a token here) must not move it.
+    from posthog.mcp._internal import get_server_tracking_data, tracking_key
+
+    client = FakeClient()
+    app, lifespan, server = make_pod(client)
+    data = get_server_tracking_data(tracking_key(server))
+    before = (data.session_id, data.session_source)
+    async with lifespan:
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+        ) as http:
+            await handshake(RoundRobin([http]))
+    await _flush()
+
+    assert len(_events(client, "$mcp_initialize")) == 1
+    assert (data.session_id, data.session_source) == before
+
+
+async def test_a_server_that_cannot_be_bound_does_not_break_requests():
+    from posthog.mcp import PostHogMcpStatelessSessionMiddleware
+
+    async def echo(scope, receive, send):
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"{}"})
+
+    for unbindable in (object(), {"not": "hashable"}):
+        app = PostHogMcpStatelessSessionMiddleware(echo, server=unbindable)
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+        ) as http:
+            response = await http.post(
+                "/mcp",
+                json=rpc("initialize", initialize_params("x")),
+                headers=BASE_HEADERS,
+            )
+        assert response.status_code == 200
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_flush_waits_for_the_handshake_capture(kind):
+    # The handshake capture starts during the request. flush() must wait for it,
+    # or shutdown drops $mcp_initialize when identify or before_send is slow.
+    from posthog.mcp import McpAnalytics
+    from posthog.mcp._internal import tracking_key
+
+    async def slow_identify(request, extra):
+        await asyncio.sleep(0.05)
+        return UserIdentity(distinct_id="user_slow")
+
+    async def slow_before_send(event):
+        await asyncio.sleep(0.05)
+        return event
+
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False,
+        identify=slow_identify,
+        before_send=slow_before_send,
+    )
+    app, lifespan, server = make_pod(client, kind=kind, options=options)
+    async with lifespan:
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+        ) as http:
+            await handshake(RoundRobin([http]), send_initialized=False)
+        await McpAnalytics(tracking_key(server)).flush()
+        assert len(_events(client, "$mcp_initialize")) == 1
+
+
+@pytest.mark.skipif(
+    MCP_MAJOR < 2,
+    reason="mcp 1.x does not read a request that carries a session id (README)",
+)
+@pytest.mark.parametrize("kind", KINDS)
+async def test_an_initialize_with_a_session_header_keeps_that_session(kind):
+    # A stateless client that sends initialize with an existing Mcp-Session-Id
+    # keeps sending it, and its later requests resolve their session from it.
+    client = FakeClient()
+    async with fleet(client, pods=2, kind=kind) as lb:
+        headers, _ = await handshake(
+            lb, extra_headers={"mcp-session-id": "an-existing-session"}
+        )
+        assert headers["mcp-session-id"] == "an-existing-session"
+        await call_add(lb, headers)
+        await call_add(lb, headers, 4)
+    await _flush()
+
+    (init,) = _events(client, "$mcp_initialize")
+    calls = _events(client, "$mcp_tool_call")
+    assert {c["properties"]["$session_id"] for c in calls} == {
+        init["properties"]["$session_id"]
+    }
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_a_hung_identify_leaves_no_task_behind(kind):
+    # identify runs inline in the handshake, as it does on a tool call. A callback
+    # that never returns holds those requests, and leaves no analytics task behind
+    # for each connection. Once the callback recovers, recording resumes.
+    import contextlib
+
+    import posthog.mcp._instrumentation as instr
+    from posthog.mcp import McpAnalytics
+    from posthog.mcp._internal import get_server_tracking_data, tracking_key
+
+    recovered = asyncio.Event()
+
+    async def identify(request, extra):
+        await recovered.wait()
+        return UserIdentity(distinct_id="user_1")
+
+    client = FakeClient()
+    options = MCPAnalyticsOptions(enable_conversation_id=False, identify=identify)
+    app, lifespan, server = make_pod(client, kind=kind, options=options)
+    data = get_server_tracking_data(tracking_key(server))
+
+    def pending():
+        with instr._tasks_lock:
+            tasks = list(instr._BACKGROUND_TASKS.items())
+        return [task for task, owner in tasks if owner is data and not task.done()]
+
+    async with lifespan:
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+        ) as http:
+            lb = RoundRobin([http])
+            for _ in range(5):  # each client gives up, as a timeout would
+                with contextlib.suppress(asyncio.TimeoutError):
+                    await asyncio.wait_for(handshake(lb, send_initialized=False), 0.2)
+            assert pending() == []
+            await asyncio.wait_for(McpAnalytics(tracking_key(server)).flush(), 1)
+
+            recovered.set()
+            await handshake(lb, client_name="after-recovery", send_initialized=False)
+    await _flush()
+
+    names = [
+        e["properties"]["$mcp_client_name"] for e in _events(client, "$mcp_initialize")
+    ]
+    assert "after-recovery" in names
+
+
+@pytest.mark.skipif(MCP_MAJOR >= 2, reason="the mcp 1.x auth context middleware")
+async def test_identify_sees_the_auth_context_of_the_handshake():
+    # FastMCP's AuthContextMiddleware sets the authenticated user for the length of
+    # the request and resets it on the way out. Our middleware sits outside it, so
+    # the handshake must be recorded while the app still handles the request.
+    from mcp.server.auth.middleware.auth_context import (
+        auth_context_var,
+        get_access_token,
+    )
+    from mcp.server.auth.middleware.bearer_auth import AuthenticatedUser
+    from mcp.server.auth.provider import AccessToken
+
+    from posthog.mcp import PostHogMcpStatelessSessionMiddleware
+
+    def with_user(app):
+        user = AuthenticatedUser(
+            AccessToken(token="t", client_id="alice", scopes=[], expires_at=None)
+        )
+
+        async def authenticated(scope, receive, send):
+            reset = auth_context_var.set(user)
+            try:
+                await app(scope, receive, send)
+            finally:
+                auth_context_var.reset(reset)
+
+        return authenticated
+
+    def identify(request, extra):
+        token = get_access_token()
+        return UserIdentity(distinct_id=token.client_id) if token else None
+
+    client = FakeClient()
+    options = MCPAnalyticsOptions(enable_conversation_id=False, identify=identify)
+    _, lifespan, server = make_pod(client, options=options)
+    app = PostHogMcpStatelessSessionMiddleware(
+        with_user(server.session_manager.handle_request), server=server
+    )
+    async with lifespan:
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://127.0.0.1:8000"
+        ) as http:
+            await handshake(RoundRobin([http]), send_initialized=False)
+    await _flush()
+
+    (init,) = _events(client, "$mcp_initialize")
+    assert init["distinct_id"] == "alice"
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_an_escaped_initialize_still_mints_a_session(kind):
+    # "\u0069nitialize" is valid JSON for "initialize". The middleware parses the
+    # body as JSON, so it mints the token and captures the handshake.
+    raw = (
+        b'{"jsonrpc":"2.0","id":1,"method":"\\u0069nitialize","params":'
+        + json.dumps(initialize_params("escaped-client")).encode()
+        + b"}"
+    )
+    client = FakeClient()
+    async with fleet(client, kind=kind) as lb:
+        response = await lb.pods[0].post("/mcp", content=raw, headers=BASE_HEADERS)
+    await _flush()
+
+    assert response.status_code == 200, response.text
+    assert decode_session_id(response.headers.get("mcp-session-id")) is not None
+    (init,) = _events(client, "$mcp_initialize")
+    assert init["properties"]["$mcp_client_name"] == "escaped-client"
+
+
+@pytest.mark.skipif(
+    MCP_MAJOR < 2,
+    reason="mcp 1.x does not read a request that carries a session id (README)",
+)
+@pytest.mark.parametrize("kind", KINDS)
+async def test_a_nested_method_before_the_top_level_initialize_is_counted(kind):
+    # JSON key order is arbitrary: params can come first, and can hold their own
+    # "method" key. Only the top-level method says whether this is a handshake.
+    params = initialize_params("nested-client")
+    params["capabilities"] = {
+        "experimental": {"vendor": {"method": "custom", "padding": "x" * 8192}}
+    }
+    body = {"params": params, "jsonrpc": "2.0", "id": 1, "method": "initialize"}
+    headers = {**BASE_HEADERS, "mcp-session-id": "an-existing-session"}
+    client = FakeClient()
+    async with fleet(client, kind=kind) as lb:
+        response = await lb.post(body, headers)
+    await _flush()
+
+    assert response.status_code == 200, response.text
+    (init,) = _events(client, "$mcp_initialize")
+    assert init["properties"]["$mcp_client_name"] == "nested-client"
diff --git a/posthog/test/mcp/test_session_token.py b/posthog/test/mcp/test_session_token.py
index 4cb0ac810..9db5aca7e 100644
--- a/posthog/test/mcp/test_session_token.py
+++ b/posthog/test/mcp/test_session_token.py
@@ -418,6 +418,36 @@ async def send(message):
     assert MCP_SESSION_HEADER not in sent["headers"]  # too big to sniff -> no mint
 
 
+async def test_middleware_passes_a_disconnect_mid_body_to_the_app():
+    """A client that disconnects while it sends the body must reach the app as a
+    disconnect, not as a complete request made of the part that arrived."""
+    messages = [
+        {"type": "http.request", "body": b'{"jsonrpc":"2.0","met', "more_body": True},
+        {"type": "http.disconnect"},
+    ]
+    seen = []
+
+    async def app(scope, receive, send):
+        while True:
+            message = await receive()
+            seen.append(message)
+            if message["type"] != "http.request" or not message.get("more_body"):
+                return
+
+    async def receive():
+        return messages.pop(0) if messages else {"type": "http.disconnect"}
+
+    async def send(message):
+        pass
+
+    await PostHogMcpStatelessSessionMiddleware(app)(_scope(), receive, send)
+
+    assert seen == [
+        {"type": "http.request", "body": b'{"jsonrpc":"2.0","met', "more_body": True},
+        {"type": "http.disconnect"},
+    ]
+
+
 # --- end-to-end against a real stateless FastMCP transport -------------------
 
 
diff --git a/posthog/test/mcp/test_v2_lowlevel.py b/posthog/test/mcp/test_v2_lowlevel.py
index 905292b1d..319cbc3eb 100644
--- a/posthog/test/mcp/test_v2_lowlevel.py
+++ b/posthog/test/mcp/test_v2_lowlevel.py
@@ -481,7 +481,7 @@ async def late_read_resource(ctx, params):
     assert reads[0]["properties"]["$mcp_resource_name"] == "file:///late.txt"
 
 
-async def test_initialize_and_session_reuse_across_calls():
+async def test_session_reuse_across_calls_without_a_handshake():
     server = make_server()
     client = FakeClient()
     instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
@@ -490,7 +490,9 @@ async def test_initialize_and_session_reuse_across_calls():
     await _call_tool(server, "add", {"a": 2, "b": 2, "context": "second"})
     await _flush()
 
-    assert len(_events(client, "$mcp_initialize")) == 1
+    # No initialize was sent, so none is reported: Server.middleware sees every
+    # real handshake (test_initialize_handshake.py).
+    assert _events(client, "$mcp_initialize") == []
     calls = _events(client, "$mcp_tool_call")
     session_ids = {c["properties"]["$session_id"] for c in calls}
     assert len(session_ids) == 1
diff --git a/posthog/test/mcp/test_v2_mcpserver.py b/posthog/test/mcp/test_v2_mcpserver.py
index cdc991ac1..4e7a5d2c1 100644
--- a/posthog/test/mcp/test_v2_mcpserver.py
+++ b/posthog/test/mcp/test_v2_mcpserver.py
@@ -195,7 +195,7 @@ async def test_tool_call_error_is_captured_and_converted():
     assert exception_list[-1]["value"] == "explode"
 
 
-async def test_initialize_emitted_once_per_session():
+async def test_tool_calls_alone_emit_no_initialize():
     server = make_server()
     client = FakeClient()
     instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
@@ -208,7 +208,9 @@ async def test_initialize_emitted_once_per_session():
     )
     await _flush()
 
-    assert len(_events(client, "$mcp_initialize")) == 1
+    # No initialize was sent, so none is reported: Server.middleware sees every
+    # real handshake (test_initialize_handshake.py).
+    assert _events(client, "$mcp_initialize") == []
     assert len(_events(client, "$mcp_tool_call")) == 2
 
 
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 52cb06d6f..d3a7b1847 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -365,6 +365,7 @@ alias posthog.mcp.asgi.MCP_SESSION_HEADER -> posthog.mcp.session_token.MCP_SESSI
 alias posthog.mcp.asgi.SessionTokenPayload -> posthog.mcp.session_token.SessionTokenPayload
 alias posthog.mcp.asgi.decode_session_id -> posthog.mcp.session_token.decode_session_id
 alias posthog.mcp.asgi.encode_session_id -> posthog.mcp.session_token.encode_session_id
+alias posthog.mcp.asgi.handshake_session_id -> posthog.mcp.session.handshake_session_id
 alias posthog.mcp.asgi.log -> posthog.mcp.logger.log
 alias posthog.mcp.asgi.new_session_id -> posthog.mcp.session.new_session_id
 alias posthog.mcp.asgi.read_mcp_session_header -> posthog.mcp.session_token.read_mcp_session_header
@@ -1295,7 +1296,7 @@ class posthog.integrations.django.PosthogContextMiddleware(get_response)
 class posthog.integrations.flask.PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None)
 class posthog.integrations.otel.PostHogContextSpanProcessor 
 class posthog.mcp.McpAnalytics(key: Any)
-class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any)
+class posthog.mcp.asgi.PostHogMcpStatelessSessionMiddleware(app: Any, server: Any = None)
 class posthog.mcp.constants.PostHogMCPAnalyticsEvent 
 class posthog.mcp.constants.PostHogMCPAnalyticsProperty 
 class posthog.mcp.posthog_mcp.PostHogMCP(api_key: str, missing_capability_tool_name: Optional[str] = None, mcp_exception_autocapture: bool = True, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, enable_conversation_id: bool = True, **kwargs: Any)

From 48889b6cc8d0a9eec579684640cb74b393cdd56c Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Fri, 23 Oct 2026 08:38:05 -0400
Subject: [PATCH 101/245] fix(ai): take cumulative usage and web searches from
 the Claude Agent SDK message_delta (#1112)

The tracker only read output_tokens from a message_delta. Its usage is cumulative,
and with server tools (web search, ...) the input and cache counts exceed the
message_start values, so streamed generations under-reported them, and the
number of web searches was never recorded. Keep the larger input and cache
counts, as the Anthropic wrapper does, and set $ai_web_search_count from
server_tool_use.web_search_requests.

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .../claude-agent-sdk-message-delta-usage.md   |  5 ++
 posthog/ai/claude_agent_sdk/processor.py      | 21 +++++-
 .../ai/claude_agent_sdk/test_processor.py     | 75 +++++++++++++++++++
 3 files changed, 100 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/claude-agent-sdk-message-delta-usage.md

diff --git a/.sampo/changesets/claude-agent-sdk-message-delta-usage.md b/.sampo/changesets/claude-agent-sdk-message-delta-usage.md
new file mode 100644
index 000000000..3db867892
--- /dev/null
+++ b/.sampo/changesets/claude-agent-sdk-message-delta-usage.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+The Claude Agent SDK integration now takes the cumulative input and cache token counts from the final `message_delta` usage, which grow past the `message_start` values when server tools such as web search run, and sets `$ai_web_search_count` from `server_tool_use.web_search_requests`. Streamed generations used to under-report input tokens and cache writes and never recorded the web search count.
diff --git a/posthog/ai/claude_agent_sdk/processor.py b/posthog/ai/claude_agent_sdk/processor.py
index 1d45b61c2..d5405ec66 100644
--- a/posthog/ai/claude_agent_sdk/processor.py
+++ b/posthog/ai/claude_agent_sdk/processor.py
@@ -51,6 +51,7 @@ class _GenerationData:
     output_tokens: Optional[int] = None
     cache_read_input_tokens: Optional[int] = None
     cache_creation_input_tokens: Optional[int] = None
+    web_search_count: Optional[int] = None
     raw_usage: Optional[Dict[str, Any]] = None
     start_time: float = 0.0
     end_time: float = 0.0
@@ -92,9 +93,25 @@ def process_stream_event(self, event: "StreamEvent") -> None:
         elif event_type == "message_delta" and self._current is not None:
             usage = raw.get("usage", {})
             self._current.raw_usage = {**(self._current.raw_usage or {}), **usage}
-            # message_delta usage reports cumulative output tokens
+            # message_delta usage is cumulative: output tokens, and with server
+            # tools (web search, ...) the input and cache counts grow past the
+            # message_start values. Keep the larger count; a field the delta
+            # omits keeps the message_start value.
             if usage.get("output_tokens"):
                 self._current.output_tokens = usage["output_tokens"]
+            for field_name in (
+                "input_tokens",
+                "cache_read_input_tokens",
+                "cache_creation_input_tokens",
+            ):
+                delta_value = usage.get(field_name)
+                current_value = getattr(self._current, field_name)
+                if isinstance(delta_value, int) and delta_value > (current_value or 0):
+                    setattr(self._current, field_name, delta_value)
+            server_tool_use = usage.get("server_tool_use") or {}
+            web_search_requests = server_tool_use.get("web_search_requests")
+            if isinstance(web_search_requests, int) and web_search_requests > 0:
+                self._current.web_search_count = web_search_requests
             # Extract stop reason from message_delta
             delta_stop_reason = raw.get("delta", {}).get("stop_reason")
             if delta_stop_reason is not None:
@@ -443,6 +460,8 @@ def _emit_generation(
             properties["$ai_cache_creation_input_tokens"] = (
                 gen.cache_creation_input_tokens
             )
+        if gen.web_search_count:
+            properties["$ai_web_search_count"] = gen.web_search_count
         if gen.raw_usage:
             properties["$ai_usage"] = gen.raw_usage
 
diff --git a/posthog/test/ai/claude_agent_sdk/test_processor.py b/posthog/test/ai/claude_agent_sdk/test_processor.py
index 3dc776002..548fb8244 100644
--- a/posthog/test/ai/claude_agent_sdk/test_processor.py
+++ b/posthog/test/ai/claude_agent_sdk/test_processor.py
@@ -221,6 +221,81 @@ async def test_emits_generation_from_stream_events(self, processor, mock_client)
         assert props["$ai_output_tokens"] == 50
         assert props["$ai_cache_read_input_tokens"] == 20
 
+    @pytest.mark.asyncio
+    async def test_message_delta_usage_is_cumulative_with_server_tools(
+        self, processor, mock_client
+    ):
+        # With server tools the final message_delta carries the cumulative input
+        # and cache counts and the number of web searches.
+        message_delta = _make_stream_event(
+            "message_delta",
+            {
+                "delta": {"stop_reason": "end_turn"},
+                "usage": {
+                    "input_tokens": 5120,
+                    "output_tokens": 300,
+                    "cache_read_input_tokens": 64,
+                    "cache_creation_input_tokens": 32,
+                    "server_tool_use": {"web_search_requests": 2},
+                },
+            },
+        )
+        messages = [
+            _make_message_start(input_tokens=120, cache_read=0, cache_creation=0),
+            message_delta,
+            _make_message_stop(),
+            _make_assistant_message(),
+            _make_result_message(),
+        ]
+
+        with patch(
+            "posthog.ai.claude_agent_sdk.processor.original_query",
+            side_effect=lambda **kw: _fake_query(messages),
+        ):
+            async for _ in processor.query(prompt="Hi", options=ClaudeAgentOptions()):
+                pass
+
+        gen_call = next(
+            c
+            for c in mock_client.capture.call_args_list
+            if (c.kwargs.get("event") or c[1].get("event")) == "$ai_generation"
+        )
+        props = gen_call.kwargs.get("properties") or gen_call[1].get("properties")
+        assert props["$ai_input_tokens"] == 5120
+        assert props["$ai_output_tokens"] == 300
+        assert props["$ai_cache_read_input_tokens"] == 64
+        assert props["$ai_cache_creation_input_tokens"] == 32
+        assert props["$ai_web_search_count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_message_delta_without_input_counts_keeps_message_start(
+        self, processor, mock_client
+    ):
+        messages = [
+            _make_message_start(input_tokens=100, cache_read=20),
+            _make_message_delta(output_tokens=50),
+            _make_message_stop(),
+            _make_assistant_message(),
+            _make_result_message(),
+        ]
+
+        with patch(
+            "posthog.ai.claude_agent_sdk.processor.original_query",
+            side_effect=lambda **kw: _fake_query(messages),
+        ):
+            async for _ in processor.query(prompt="Hi", options=ClaudeAgentOptions()):
+                pass
+
+        gen_call = next(
+            c
+            for c in mock_client.capture.call_args_list
+            if (c.kwargs.get("event") or c[1].get("event")) == "$ai_generation"
+        )
+        props = gen_call.kwargs.get("properties") or gen_call[1].get("properties")
+        assert props["$ai_input_tokens"] == 100
+        assert props["$ai_cache_read_input_tokens"] == 20
+        assert "$ai_web_search_count" not in props
+
     @pytest.mark.asyncio
     async def test_emits_cache_creation_ttl_breakdown_from_stream_events(
         self, processor, mock_client

From 5a2ea5f7e0c71d6b9dc70112ab9d5c29c6f99bb1 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:38:51 +0000
Subject: [PATCH 102/245] chore: Release v7.75.9 [skip ci]

---
 .../claude-agent-sdk-message-delta-usage.md         |  5 -----
 .sampo/changesets/mcp-initialize-per-handshake.md   | 11 -----------
 openfeature-provider/CHANGELOG.md                   |  6 ++++++
 openfeature-provider/pyproject.toml                 |  2 +-
 posthog/CHANGELOG.md                                | 13 +++++++++++++
 posthog/version.py                                  |  2 +-
 pyproject.toml                                      |  2 +-
 uv.lock                                             |  4 ++--
 8 files changed, 24 insertions(+), 21 deletions(-)
 delete mode 100644 .sampo/changesets/claude-agent-sdk-message-delta-usage.md
 delete mode 100644 .sampo/changesets/mcp-initialize-per-handshake.md

diff --git a/.sampo/changesets/claude-agent-sdk-message-delta-usage.md b/.sampo/changesets/claude-agent-sdk-message-delta-usage.md
deleted file mode 100644
index 3db867892..000000000
--- a/.sampo/changesets/claude-agent-sdk-message-delta-usage.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-The Claude Agent SDK integration now takes the cumulative input and cache token counts from the final `message_delta` usage, which grow past the `message_start` values when server tools such as web search run, and sets `$ai_web_search_count` from `server_tool_use.web_search_requests`. Streamed generations used to under-report input tokens and cache writes and never recorded the web search count.
diff --git a/.sampo/changesets/mcp-initialize-per-handshake.md b/.sampo/changesets/mcp-initialize-per-handshake.md
deleted file mode 100644
index 33d926d09..000000000
--- a/.sampo/changesets/mcp-initialize-per-handshake.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-pypi/posthog: patch
----
-
-MCP analytics now sends one `$mcp_initialize` for each `initialize` request that a client sends.
-
-Before, the SDK sent the event on the first request of each session, once per process. A stateless fleet sent one event for each pod that a session reached. A conversation-anchored session sent another event. A client that connected and sent no other request sent no event.
-
-On MCP SDK 2.x, the event comes from `Server.middleware` on every transport. Requests on the 2026-07-28 spec, which has no `initialize`, no longer send one. On MCP SDK 1.x over HTTP, the event comes from `PostHogMcpStatelessSessionMiddleware`. The apps that `instrument()` autowires get this with no change. If you mount the middleware by hand, pass the server as `server=`. MCP SDK 1.x over stdio keeps the first request as the trigger.
-
-The event now also has the handshake request as `$mcp_parameters`. On MCP SDK 2.x, it also has the server reply as `$mcp_response`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 41701c155..db08dcd7c 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.123 — 2026-10-23
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.9
+
 ## 0.1.122 — 2026-10-23
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index c2f161eb5..11ec73ea3 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.122"
+version = "0.1.123"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5daf73be8..5a6bf681b 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,18 @@
 # posthog
 
+## 7.75.9 — 2026-10-23
+
+### Patch changes
+
+- [8cd8eb5](https://github.com/posthog/posthog-python/commit/8cd8eb5b6fdcdb19db4c4d07fe911c6eb3976d5a) MCP analytics now sends one `$mcp_initialize` for each `initialize` request that a client sends.
+  
+  Before, the SDK sent the event on the first request of each session, once per process. A stateless fleet sent one event for each pod that a session reached. A conversation-anchored session sent another event. A client that connected and sent no other request sent no event.
+  
+  On MCP SDK 2.x, the event comes from `Server.middleware` on every transport. Requests on the 2026-07-28 spec, which has no `initialize`, no longer send one. On MCP SDK 1.x over HTTP, the event comes from `PostHogMcpStatelessSessionMiddleware`. The apps that `instrument()` autowires get this with no change. If you mount the middleware by hand, pass the server as `server=`. MCP SDK 1.x over stdio keeps the first request as the trigger.
+  
+  The event now also has the handshake request as `$mcp_parameters`. On MCP SDK 2.x, it also has the server reply as `$mcp_response`. — Thanks @gesh!
+- [48889b6](https://github.com/posthog/posthog-python/commit/48889b6cc8d0a9eec579684640cb74b393cdd56c) The Claude Agent SDK integration now takes the cumulative input and cache token counts from the final `message_delta` usage, which grow past the `message_start` values when server tools such as web search run, and sets `$ai_web_search_count` from `server_tool_use.web_search_requests`. Streamed generations used to under-report input tokens and cache writes and never recorded the web search count. — Thanks @pcbeingused333!
+
 ## 7.75.8 — 2026-10-23
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 42ba1010a..50da243ae 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.8"
+VERSION = "7.75.9"
diff --git a/pyproject.toml b/pyproject.toml
index d77bc3082..ef4e840a1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.8"
+version = "7.75.9"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index fe2c8245b..070b8426b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.122"
+version = "0.1.123"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3024,7 +3024,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.8"
+version = "7.75.9"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From e3fd9a49c6ca1beeb2d4f9b6a889ea7ee0774f57 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:38:57 +0000
Subject: [PATCH 103/245] Update generated references

---
 .../posthog-python-references-7.75.9.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.9.json

diff --git a/references/posthog-python-references-7.75.9.json b/references/posthog-python-references-7.75.9.json
new file mode 100644
index 000000000..3ced9019c
--- /dev/null
+++ b/references/posthog-python-references-7.75.9.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.9",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index bacd9eaf2..3ced9019c 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.8",
+    "version": "7.75.9",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 25d2767a70378da02c321879f0fa3a2e52d071b7 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Fri, 23 Oct 2026 08:42:33 -0400
Subject: [PATCH 104/245] fix(ai): record the HTTP status of google-genai
 errors (#1110)

* fix(ai): record the HTTP status of google-genai errors

The generation and embedding wrappers read the HTTP status of a failed call from
the exception's status_code, which OpenAI and Anthropic errors have. google-genai's
APIError (ClientError, ServerError) carries it as code, so every failed Gemini
call was captured with $ai_http_status 0. Read either attribute through a small
helper; a code outside the HTTP range still counts as no status.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix: remove unused import from HTTP status tests

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .sampo/changesets/gemini-error-http-status.md |   5 +
 posthog/ai/gemini/_shared.py                  |   5 +-
 posthog/ai/utils.py                           |  23 +++-
 posthog/test/ai/test_http_status.py           | 124 ++++++++++++++++++
 4 files changed, 148 insertions(+), 9 deletions(-)
 create mode 100644 .sampo/changesets/gemini-error-http-status.md
 create mode 100644 posthog/test/ai/test_http_status.py

diff --git a/.sampo/changesets/gemini-error-http-status.md b/.sampo/changesets/gemini-error-http-status.md
new file mode 100644
index 000000000..4cc01a508
--- /dev/null
+++ b/.sampo/changesets/gemini-error-http-status.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Failed Gemini calls are now captured with the HTTP status of the error as `$ai_http_status` (for example 429 or 503) instead of 0. google-genai errors carry the status as `code` rather than `status_code`, which the OpenAI and Anthropic wrappers already read.
diff --git a/posthog/ai/gemini/_shared.py b/posthog/ai/gemini/_shared.py
index e1036929d..b9f710c09 100644
--- a/posthog/ai/gemini/_shared.py
+++ b/posthog/ai/gemini/_shared.py
@@ -16,6 +16,7 @@
     _capture_ai_event,
     capture_streaming_event,
     finalize_ai_content,
+    _get_http_status,
     merge_system_prompt,
     with_privacy_mode,
 )
@@ -252,9 +253,7 @@ def _capture_embedding_outcome(
                 privacy_mode,
                 finalize_ai_content(contents, self._ph_client),
             ),
-            "$ai_http_status": (
-                getattr(error, "status_code", 0) if error is not None else 200
-            ),
+            "$ai_http_status": (_get_http_status(error) if error is not None else 200),
             # Omitted when the provider never reported a count: absent means
             # unknown, 0 is a report of nothing.
             **({"$ai_input_tokens": input_tokens} if input_tokens is not None else {}),
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index 5f2b956e0..0ae5e9f47 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -453,6 +453,21 @@ def merge_system_prompt(
     return []
 
 
+def _get_http_status(exc: BaseException) -> int:
+    """HTTP status of an SDK exception, 0 when it has none.
+
+    OpenAI and Anthropic errors carry `status_code`; google-genai's `APIError`
+    carries the status as `code`.
+    """
+    status = getattr(exc, "status_code", None)
+    if isinstance(status, int):
+        return status
+    code = getattr(exc, "code", None)
+    if isinstance(code, int) and not isinstance(code, bool) and 100 <= code <= 599:
+        return code
+    return 0
+
+
 def call_llm_and_track_usage(
     posthog_distinct_id: Optional[str],
     ph_client: PostHogClient,
@@ -484,9 +499,7 @@ def call_llm_and_track_usage(
             response = call_method(**kwargs)
         except Exception as exc:
             error = exc
-            http_status = getattr(
-                exc, "status_code", 0
-            )  # default to 0 becuase its likely an SDK error
+            http_status = _get_http_status(exc)  # 0 because its likely an SDK error
             error_params = {
                 "$ai_is_error": True,
                 "$ai_error": exc.__str__(),
@@ -658,9 +671,7 @@ async def call_llm_and_track_usage_async(
             raise
         except Exception as exc:
             error = exc
-            http_status = getattr(
-                exc, "status_code", 0
-            )  # default to 0 because its likely an SDK error
+            http_status = _get_http_status(exc)  # 0 because its likely an SDK error
             error_params = {
                 "$ai_is_error": True,
                 "$ai_error": exc.__str__(),
diff --git a/posthog/test/ai/test_http_status.py b/posthog/test/ai/test_http_status.py
new file mode 100644
index 000000000..1f79fa276
--- /dev/null
+++ b/posthog/test/ai/test_http_status.py
@@ -0,0 +1,124 @@
+"""Failed provider calls are recorded with the HTTP status of the SDK error."""
+
+from unittest.mock import patch
+
+import pytest
+
+from posthog.ai.utils import (
+    call_llm_and_track_usage,
+    call_llm_and_track_usage_async,
+    _get_http_status,
+)
+
+
+@pytest.fixture
+def mock_client():
+    with patch("posthog.client.Client") as mock_client:
+        mock_client.privacy_mode = False
+        yield mock_client
+
+
+class _WithStatusCode(Exception):
+    status_code = 503
+
+
+class _WithCode(Exception):
+    def __init__(self, code):
+        super().__init__("boom")
+        self.code = code
+
+
+def test_get_http_status():
+    assert _get_http_status(_WithStatusCode()) == 503
+    assert _get_http_status(_WithCode(429)) == 429
+    # A `code` that is not an HTTP status is not one
+    assert _get_http_status(_WithCode(2)) == 0
+    assert _get_http_status(_WithCode("RESOURCE_EXHAUSTED")) == 0
+    assert _get_http_status(RuntimeError("no status")) == 0
+
+
+def _genai_errors():
+    errors = pytest.importorskip("google.genai.errors")
+    return errors
+
+
+def _gemini_error(errors, cls, code):
+    return cls(code, {"error": {"code": code, "message": "nope", "status": "ERROR"}})
+
+
+@pytest.mark.parametrize(
+    ("cls_name", "code"), [("ClientError", 429), ("ServerError", 503)]
+)
+def test_gemini_api_error_status_is_recorded(mock_client, cls_name, code):
+    errors = _genai_errors()
+    err = _gemini_error(errors, getattr(errors, cls_name), code)
+
+    def boom(**kwargs):
+        raise err
+
+    with pytest.raises(getattr(errors, cls_name)):
+        call_llm_and_track_usage(
+            "user",
+            mock_client,
+            "gemini",
+            None,
+            None,
+            False,
+            None,
+            "https://generativelanguage.googleapis.com",
+            boom,
+            model="gemini-3.8-flash",
+            contents="hi",
+        )
+
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == code
+
+
+@pytest.mark.asyncio
+async def test_gemini_api_error_status_is_recorded_async(mock_client):
+    errors = _genai_errors()
+    err = _gemini_error(errors, errors.ClientError, 429)
+
+    async def boom(**kwargs):
+        raise err
+
+    with pytest.raises(errors.ClientError):
+        await call_llm_and_track_usage_async(
+            "user",
+            mock_client,
+            "gemini",
+            None,
+            None,
+            False,
+            None,
+            "https://generativelanguage.googleapis.com",
+            boom,
+            model="gemini-3.8-flash",
+            contents="hi",
+        )
+
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_http_status"] == 429
+
+
+def test_status_code_errors_keep_their_status(mock_client):
+    def boom(**kwargs):
+        raise _WithStatusCode("overloaded")
+
+    with pytest.raises(_WithStatusCode):
+        call_llm_and_track_usage(
+            "user",
+            mock_client,
+            "openai",
+            None,
+            None,
+            False,
+            None,
+            "https://x",
+            boom,
+            model="m",
+        )
+
+    assert mock_client.capture.call_args[1]["properties"]["$ai_http_status"] == 503

From 82f948b0871ecbbf5c6fd30714481dc5877adbf1 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:44:06 +0000
Subject: [PATCH 105/245] chore: Release v7.75.10 [skip ci]

---
 .sampo/changesets/gemini-error-http-status.md | 5 -----
 openfeature-provider/CHANGELOG.md             | 6 ++++++
 openfeature-provider/pyproject.toml           | 2 +-
 posthog/CHANGELOG.md                          | 6 ++++++
 posthog/version.py                            | 2 +-
 pyproject.toml                                | 2 +-
 uv.lock                                       | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/gemini-error-http-status.md

diff --git a/.sampo/changesets/gemini-error-http-status.md b/.sampo/changesets/gemini-error-http-status.md
deleted file mode 100644
index 4cc01a508..000000000
--- a/.sampo/changesets/gemini-error-http-status.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Failed Gemini calls are now captured with the HTTP status of the error as `$ai_http_status` (for example 429 or 503) instead of 0. google-genai errors carry the status as `code` rather than `status_code`, which the OpenAI and Anthropic wrappers already read.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index db08dcd7c..4ba230b60 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.124 — 2026-10-23
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.10
+
 ## 0.1.123 — 2026-10-23
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 11ec73ea3..32ef79c50 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.123"
+version = "0.1.124"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5a6bf681b..0b165616b 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.75.10 — 2026-10-23
+
+### Patch changes
+
+- [25d2767](https://github.com/posthog/posthog-python/commit/25d2767a70378da02c321879f0fa3a2e52d071b7) Failed Gemini calls are now captured with the HTTP status of the error as `$ai_http_status` (for example 429 or 503) instead of 0. google-genai errors carry the status as `code` rather than `status_code`, which the OpenAI and Anthropic wrappers already read. — Thanks @pcbeingused333!
+
 ## 7.75.9 — 2026-10-23
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 50da243ae..80d27f167 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.9"
+VERSION = "7.75.10"
diff --git a/pyproject.toml b/pyproject.toml
index ef4e840a1..fd257b27f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.9"
+version = "7.75.10"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 070b8426b..ce6945262 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.123"
+version = "0.1.124"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3024,7 +3024,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.9"
+version = "7.75.10"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From b0a2783b53e7a8e5546f11674318225b26139ec4 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:44:11 +0000
Subject: [PATCH 106/245] Update generated references

---
 .../posthog-python-references-7.75.10.json    | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.10.json

diff --git a/references/posthog-python-references-7.75.10.json b/references/posthog-python-references-7.75.10.json
new file mode 100644
index 000000000..226ca01c2
--- /dev/null
+++ b/references/posthog-python-references-7.75.10.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.10",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 3ced9019c..226ca01c2 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.9",
+    "version": "7.75.10",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 04e6a4c1c4f15e4dd0d010dee5fa83244f9b6dd8 Mon Sep 17 00:00:00 2001
From: Carlos Marchal <carlos@posthog.com>
Date: Fri, 23 Oct 2026 17:22:17 +0200
Subject: [PATCH 107/245] fix(aio): keep content out of ai events in privacy
 mode (#1105)

* fix: ai privacy mode leaks

* fix: address privacy mode review findings

* fix: strip remaining otel content in privacy mode

* fix: redact mcp credentials in otel tool definitions

* fix: address otel privacy review findings

* fix: always redact mcp credentials in otel tool definitions

* fix: strip otel embedding vectors in privacy mode

* fix: drop only the otel span that fails redaction

* fix: keep vercel rerank scores in otel privacy mode

* fix: strip logfire payload attributes in otel privacy mode
---
 .sampo/changesets/ai-privacy-mode-leaks.md   |  12 +
 posthog/ai/anthropic/anthropic_converter.py  |   4 +-
 posthog/ai/gemini/_shared.py                 |  12 +-
 posthog/ai/gemini/gemini.py                  |   6 +-
 posthog/ai/gemini/gemini_async.py            |   6 +-
 posthog/ai/gemini/gemini_converter.py        |   4 +-
 posthog/ai/langchain/callbacks.py            |  69 +-
 posthog/ai/langchain/middleware.py           |  12 +-
 posthog/ai/openai/openai_converter.py        |   8 +-
 posthog/ai/openai_agents/processor.py        |  36 +-
 posthog/ai/otel/_privacy.py                  | 344 ++++++++
 posthog/ai/otel/exporter.py                  |  17 +-
 posthog/ai/otel/processor.py                 |  18 +-
 posthog/ai/utils.py                          | 234 +++++-
 posthog/test/ai/gemini/test_gemini_parity.py |  20 +-
 posthog/test/ai/langchain/test_callbacks.py  |  22 +-
 posthog/test/ai/langchain/test_middleware.py |   2 +-
 posthog/test/ai/test_privacy_mode.py         | 800 +++++++++++++++++++
 references/public_api_snapshot.txt           |   6 +-
 19 files changed, 1548 insertions(+), 84 deletions(-)
 create mode 100644 .sampo/changesets/ai-privacy-mode-leaks.md
 create mode 100644 posthog/ai/otel/_privacy.py
 create mode 100644 posthog/test/ai/test_privacy_mode.py

diff --git a/.sampo/changesets/ai-privacy-mode-leaks.md b/.sampo/changesets/ai-privacy-mode-leaks.md
new file mode 100644
index 000000000..8eb4ececd
--- /dev/null
+++ b/.sampo/changesets/ai-privacy-mode-leaks.md
@@ -0,0 +1,12 @@
+---
+pypi/posthog: patch
+---
+
+Privacy mode now covers error text and the remaining content paths in the AI integrations.
+
+- `$ai_error` no longer carries the exception message when privacy mode is on. Provider errors and validation errors often quote the prompt or the model output, so the SDK now sends a summary built only from structured fields: the class name, HTTP status, provider error code, `param`, request ID and the class names of chained causes (for example `BadRequestError: 400 invalid_request_error param=messages[3].content request_id=req_123`). This applies to the OpenAI, Anthropic and Gemini wrappers (including Gemini embeddings), LangChain generations, spans and traces, and OpenAI Agents spans.
+- The LangChain callback handler no longer sends an `$exception` event for a failed run when privacy mode is on.
+- `$ai_tools` masks the `headers` and `authorization` of MCP tool definitions (`type: "mcp"`) with `[REDACTED]`, with or without privacy mode. The tools you pass in are not modified.
+- Gemini: a per-call `posthog_privacy_mode=False` no longer turns off privacy mode set on the client, matching the OpenAI and Anthropic wrappers.
+- OpenAI Agents: privacy mode now redacts `$ai_trace_metadata` and the `prompt` and `instructions` in transcription and speech span `model_config`.
+- OpenTelemetry: `PostHogSpanProcessor` and `PostHogTraceExporter` accept `privacy_mode` and `client`, and also honor the client's (or the module-level) `privacy_mode`. When on, exported spans drop prompt, completion, tool argument and tool result attributes, non-exception span events, exception messages and stack traces, and the span status description.
diff --git a/posthog/ai/anthropic/anthropic_converter.py b/posthog/ai/anthropic/anthropic_converter.py
index 650c5587f..1e476c5c5 100644
--- a/posthog/ai/anthropic/anthropic_converter.py
+++ b/posthog/ai/anthropic/anthropic_converter.py
@@ -18,7 +18,7 @@
     TokenUsage,
     ToolInProgress,
 )
-from posthog.ai.utils import serialize_raw_usage
+from posthog.ai.utils import _redact_mcp_tool_credentials, serialize_raw_usage
 
 
 def format_anthropic_response(response: Any) -> List[FormattedMessage]:
@@ -153,7 +153,7 @@ def extract_anthropic_tools(kwargs: Dict[str, Any]) -> Optional[Any]:
         Tool definitions if present, None otherwise
     """
 
-    return kwargs.get("tools", None)
+    return _redact_mcp_tool_credentials(kwargs.get("tools", None))
 
 
 def format_anthropic_streaming_content(
diff --git a/posthog/ai/gemini/_shared.py b/posthog/ai/gemini/_shared.py
index b9f710c09..cdff0fc30 100644
--- a/posthog/ai/gemini/_shared.py
+++ b/posthog/ai/gemini/_shared.py
@@ -16,6 +16,7 @@
     _capture_ai_event,
     capture_streaming_event,
     finalize_ai_content,
+    _format_ai_error,
     _get_http_status,
     merge_system_prompt,
     with_privacy_mode,
@@ -176,11 +177,8 @@ def _merge_posthog_params(
             if call_distinct_id is not None
             else self._default_distinct_id
         )
-        privacy_mode = (
-            call_privacy_mode
-            if call_privacy_mode is not None
-            else self._default_privacy_mode
-        )
+        # A call can add redaction but never lift the client default.
+        privacy_mode = self._default_privacy_mode or call_privacy_mode is True
         groups = call_groups if call_groups is not None else self._default_groups
 
         properties = dict(self._default_properties)
@@ -265,7 +263,9 @@ def _capture_embedding_outcome(
 
         if error:
             event_properties["$ai_is_error"] = True
-            event_properties["$ai_error"] = str(error)
+            event_properties["$ai_error"] = _format_ai_error(
+                self._ph_client, privacy_mode, error
+            )
 
         if distinct_id is None:
             event_properties["$process_person_profile"] = False
diff --git a/posthog/ai/gemini/gemini.py b/posthog/ai/gemini/gemini.py
index c5006544a..dad87da9a 100644
--- a/posthog/ai/gemini/gemini.py
+++ b/posthog/ai/gemini/gemini.py
@@ -87,7 +87,7 @@ def __init__(
             posthog_client: PostHog client for tracking usage
             posthog_distinct_id: Default distinct ID for all calls (can be overridden per call)
             posthog_properties: Default properties for all calls (can be overridden per call)
-            posthog_privacy_mode: Default privacy mode for all calls (can be overridden per call)
+            posthog_privacy_mode: Default privacy mode for all calls (a call can enable it, not disable it)
             posthog_groups: Default groups for all calls (can be overridden per call)
             **kwargs: Additional arguments (for future compatibility)
         """
@@ -212,7 +212,7 @@ def generate_content(
             posthog_distinct_id: ID to associate with the usage event (overrides client default)
             posthog_trace_id: Trace UUID for linking events (auto-generated if not provided)
             posthog_properties: Extra properties to include in the event (merged with client defaults)
-            posthog_privacy_mode: Whether to redact sensitive information (overrides client default)
+            posthog_privacy_mode: Whether to redact sensitive information (cannot disable a client default of True)
             posthog_groups: Group analytics properties (overrides client default)
             **kwargs: Arguments passed to Gemini's generate_content
         """
@@ -384,7 +384,7 @@ def embed_content(
             posthog_distinct_id: ID to associate with the usage event (overrides client default)
             posthog_trace_id: Trace UUID for linking events (auto-generated if not provided)
             posthog_properties: Extra properties to include in the event (merged with client defaults)
-            posthog_privacy_mode: Whether to redact sensitive information (overrides client default)
+            posthog_privacy_mode: Whether to redact sensitive information (cannot disable a client default of True)
             posthog_groups: Group analytics properties (overrides client default)
             **kwargs: Arguments passed to Gemini's embed_content (e.g., config)
         """
diff --git a/posthog/ai/gemini/gemini_async.py b/posthog/ai/gemini/gemini_async.py
index 0580b285b..6c70efd9b 100644
--- a/posthog/ai/gemini/gemini_async.py
+++ b/posthog/ai/gemini/gemini_async.py
@@ -82,7 +82,7 @@ def __init__(
             posthog_client: PostHog client for tracking usage
             posthog_distinct_id: Default distinct ID for all calls (can be overridden per call)
             posthog_properties: Default properties for all calls (can be overridden per call)
-            posthog_privacy_mode: Default privacy mode for all calls (can be overridden per call)
+            posthog_privacy_mode: Default privacy mode for all calls (a call can enable it, not disable it)
             posthog_groups: Default groups for all calls (can be overridden per call)
             **kwargs: Additional arguments (for future compatibility)
         """
@@ -196,7 +196,7 @@ async def generate_content(
             posthog_distinct_id: ID to associate with the usage event (overrides client default)
             posthog_trace_id: Trace UUID for linking events (auto-generated if not provided)
             posthog_properties: Extra properties to include in the event (merged with client defaults)
-            posthog_privacy_mode: Whether to redact sensitive information (overrides client default)
+            posthog_privacy_mode: Whether to redact sensitive information (cannot disable a client default of True)
             posthog_groups: Group analytics properties (overrides client default)
             **kwargs: Arguments passed to Gemini's generate_content
         """
@@ -371,7 +371,7 @@ async def embed_content(
             posthog_distinct_id: ID to associate with the usage event (overrides client default)
             posthog_trace_id: Trace UUID for linking events (auto-generated if not provided)
             posthog_properties: Extra properties to include in the event (merged with client defaults)
-            posthog_privacy_mode: Whether to redact sensitive information (overrides client default)
+            posthog_privacy_mode: Whether to redact sensitive information (cannot disable a client default of True)
             posthog_groups: Group analytics properties (overrides client default)
             **kwargs: Arguments passed to Gemini's embed_content (e.g., config)
         """
diff --git a/posthog/ai/gemini/gemini_converter.py b/posthog/ai/gemini/gemini_converter.py
index 669f63295..ae4522746 100644
--- a/posthog/ai/gemini/gemini_converter.py
+++ b/posthog/ai/gemini/gemini_converter.py
@@ -13,7 +13,7 @@
     FormattedMessage,
     TokenUsage,
 )
-from posthog.ai.utils import serialize_raw_usage
+from posthog.ai.utils import _redact_mcp_tool_credentials, serialize_raw_usage
 
 _MEDIA_KINDS = {"image": "image", "video": "video", "audio": "audio"}
 _BARE_PART_KEYS = {
@@ -364,7 +364,7 @@ def extract_gemini_tools(kwargs: Dict[str, Any]) -> Optional[Any]:
     """
 
     if "config" in kwargs and hasattr(kwargs["config"], "tools"):
-        return kwargs["config"].tools
+        return _redact_mcp_tool_credentials(kwargs["config"].tools)
 
     return None
 
diff --git a/posthog/ai/langchain/callbacks.py b/posthog/ai/langchain/callbacks.py
index 5f996fb6c..7c07d9314 100644
--- a/posthog/ai/langchain/callbacks.py
+++ b/posthog/ai/langchain/callbacks.py
@@ -47,7 +47,10 @@
     _capture_ai_event,
     _extract_cache_creation_ttl_breakdown,
     finalize_ai_content,
+    _format_ai_error,
     get_model_params,
+    _privacy_mode_enabled,
+    _redact_mcp_tool_credentials,
     _responses_stop_reason,
     with_privacy_mode,
 )
@@ -560,14 +563,12 @@ def _capture_trace_or_span(
             event_properties.update(self._properties)
 
         if isinstance(outputs, BaseException):
-            event_properties["$ai_error"] = _stringify_exception(outputs)
+            event_properties["$ai_error"] = _format_ai_error(
+                self._ph_client, self._privacy_mode, outputs, _stringify_exception
+            )
             event_properties["$ai_is_error"] = True
-            event_properties = _capture_exception_and_update_properties(
-                self._ph_client,
-                outputs,
-                self._distinct_id,
-                self._groups,
-                event_properties,
+            event_properties = self._capture_exception_and_update_properties(
+                outputs, event_properties
             )
 
         elif outputs is not None:
@@ -588,6 +589,25 @@ def _capture_trace_or_span(
             groups=self._groups,
         )
 
+    def _capture_exception_and_update_properties(
+        self, exception: BaseException, event_properties: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        # An `$exception` event carries the message and stack, which echo prompts and output.
+        if not self._ph_client.enable_exception_autocapture or _privacy_mode_enabled(
+            self._ph_client, self._privacy_mode
+        ):
+            return event_properties
+
+        exception_id = self._ph_client.capture_exception(
+            exception,
+            distinct_id=self._distinct_id,
+            groups=self._groups,
+            properties=event_properties,
+        )
+        if exception_id:
+            event_properties["$exception_event_id"] = exception_id
+        return event_properties
+
     def _pop_run_and_capture_generation(
         self,
         run_id: UUID,
@@ -657,7 +677,7 @@ def _capture_generation(
             event_properties.update(run.posthog_properties)
 
         if run.tools:
-            event_properties["$ai_tools"] = run.tools
+            event_properties["$ai_tools"] = _redact_mcp_tool_credentials(run.tools)
 
         if self._properties:
             event_properties.update(self._properties)
@@ -667,15 +687,13 @@ def _capture_generation(
 
         if isinstance(output, BaseException):
             event_properties["$ai_http_status"] = _get_http_status(output)
-            event_properties["$ai_error"] = _stringify_exception(output)
+            event_properties["$ai_error"] = _format_ai_error(
+                self._ph_client, self._privacy_mode, output, _stringify_exception
+            )
             event_properties["$ai_is_error"] = True
 
-            event_properties = _capture_exception_and_update_properties(
-                self._ph_client,
-                output,
-                self._distinct_id,
-                self._groups,
-                event_properties,
+            event_properties = self._capture_exception_and_update_properties(
+                output, event_properties
             )
         else:
             # Add usage
@@ -1011,27 +1029,6 @@ def _parse_usage(
     return llm_usage
 
 
-def _capture_exception_and_update_properties(
-    client: Client,
-    exception: BaseException,
-    distinct_id: Optional[Union[str, int, UUID]],
-    groups: Optional[Dict[str, Any]],
-    event_properties: Dict[str, Any],
-):
-    if client.enable_exception_autocapture:
-        exception_id = client.capture_exception(
-            exception,
-            distinct_id=distinct_id,
-            groups=groups,
-            properties=event_properties,
-        )
-
-        if exception_id:
-            event_properties["$exception_event_id"] = exception_id
-
-    return event_properties
-
-
 def _get_http_status(error: BaseException) -> int:
     # OpenAI: https://github.com/openai/openai-python/blob/main/src/openai/_exceptions.py
     # Anthropic: https://github.com/anthropics/anthropic-sdk-python/blob/main/src/anthropic/_exceptions.py
diff --git a/posthog/ai/langchain/middleware.py b/posthog/ai/langchain/middleware.py
index 34783747e..8cf282a87 100644
--- a/posthog/ai/langchain/middleware.py
+++ b/posthog/ai/langchain/middleware.py
@@ -21,6 +21,7 @@
 from langgraph.errors import GraphBubbleUp
 from langgraph.types import Command
 from ...client import Client
+from ..utils import _with_privacy_safe_message
 from .callbacks import (
     CallbackHandler,
     GenerationMetadata,
@@ -329,13 +330,10 @@ def _privacy_mode_enabled(self) -> bool:
             or getattr(self._callback._ph_client, "privacy_mode", False)
         )
 
-    def _returned_tool_error(self, response: ToolMessage) -> RuntimeError:
-        message = (
-            "Tool returned an error"
-            if self._privacy_mode_enabled()
-            else str(response.content)
-        )
-        return RuntimeError(message)
+    def _returned_tool_error(self, response: ToolMessage) -> BaseException:
+        if self._privacy_mode_enabled():
+            return _with_privacy_safe_message(RuntimeError("Tool returned an error"))
+        return RuntimeError(str(response.content))
 
     @staticmethod
     def _normalize_tool(tool: Any) -> dict[str, Any]:
diff --git a/posthog/ai/openai/openai_converter.py b/posthog/ai/openai/openai_converter.py
index 78487d19c..6faf1a6e9 100644
--- a/posthog/ai/openai/openai_converter.py
+++ b/posthog/ai/openai/openai_converter.py
@@ -17,7 +17,11 @@
     FormattedTextContent,
     TokenUsage,
 )
-from posthog.ai.utils import _responses_stop_reason, serialize_raw_usage
+from posthog.ai.utils import (
+    _responses_stop_reason,
+    _redact_mcp_tool_credentials,
+    serialize_raw_usage,
+)
 
 
 def _item_attr(item: Any, name: str, default: Any = None) -> Any:
@@ -299,7 +303,7 @@ def extract_openai_tools(kwargs: Dict[str, Any]) -> Optional[Any]:
 
     # Check for tools parameter (newer API)
     if "tools" in kwargs:
-        return kwargs["tools"]
+        return _redact_mcp_tool_credentials(kwargs["tools"])
 
     # Check for functions parameter (older API)
     if "functions" in kwargs:
diff --git a/posthog/ai/openai_agents/processor.py b/posthog/ai/openai_agents/processor.py
index 8bdea6c7e..e3e8450e2 100644
--- a/posthog/ai/openai_agents/processor.py
+++ b/posthog/ai/openai_agents/processor.py
@@ -25,12 +25,16 @@
 from posthog.ai.utils import (
     _capture_processor_event,
     finalize_ai_content,
+    _format_error_summary,
+    _privacy_mode_enabled,
     with_privacy_mode as _with_privacy_mode,
 )
 from posthog.client import Client
 
 log = logging.getLogger("posthog")
 
+_AUDIO_MODEL_CONFIG_CONTENT_KEYS = frozenset({"prompt", "instructions"})
+
 
 def _parse_iso_timestamp(iso_str: Optional[str]) -> Optional[float]:
     """Parse ISO timestamp to Unix timestamp."""
@@ -125,6 +129,15 @@ def _with_privacy_mode(self, value: Any) -> Any:
         """Apply privacy mode redaction if enabled."""
         return _with_privacy_mode(self._client, self._privacy_mode, value)
 
+    def _privacy_enabled(self) -> bool:
+        return _privacy_mode_enabled(self._client, self._privacy_mode)
+
+    @staticmethod
+    def _summarize_span_error(error_info: Any) -> str:
+        # Agents SDK span errors are plain dicts, not exceptions: only a type name is structured.
+        error_type = error_info.get("type") if isinstance(error_info, dict) else None
+        return _format_error_summary(error_type)
+
     def _evict_stale_entries(self) -> None:
         """Evict oldest entries if dicts exceed max size to prevent unbounded growth."""
         if len(self._span_start_times) > self._max_tracked_entries:
@@ -226,7 +239,9 @@ def on_trace_end(self, trace: Trace) -> None:
 
             # Include trace metadata if present
             if metadata:
-                properties["$ai_trace_metadata"] = _ensure_serializable(metadata)
+                properties["$ai_trace_metadata"] = self._with_privacy_mode(
+                    _ensure_serializable(metadata)
+                )
 
             if distinct_id is None:
                 properties["$process_person_profile"] = False
@@ -313,7 +328,11 @@ def on_span_end(self, span: Span[Any]) -> None:
 
                 error_properties = {
                     "$ai_is_error": True,
-                    "$ai_error": error_message,
+                    "$ai_error": (
+                        self._summarize_span_error(error_info)
+                        if self._privacy_enabled()
+                        else error_message
+                    ),
                     "$ai_error_type": error_type,
                 }
 
@@ -778,7 +797,9 @@ def _handle_audio_span(
 
         # Add model config if available (pass-through property)
         if hasattr(span_data, "model_config") and span_data.model_config:
-            properties["model_config"] = _ensure_serializable(span_data.model_config)
+            properties["model_config"] = self._redact_audio_model_config(
+                _ensure_serializable(span_data.model_config)
+            )
 
         # Add time to first audio byte for speech spans (pass-through property)
         if hasattr(span_data, "first_content_at") and span_data.first_content_at:
@@ -825,6 +846,15 @@ def _handle_audio_span(
 
         self._capture_event("$ai_span", properties, distinct_id)
 
+    def _redact_audio_model_config(self, model_config: Any) -> Any:
+        # The STT prompt and TTS instructions are user-authored text.
+        if not isinstance(model_config, dict) or not self._privacy_enabled():
+            return model_config
+        return {
+            key: (None if key in _AUDIO_MODEL_CONFIG_CONTENT_KEYS else value)
+            for key, value in model_config.items()
+        }
+
     def _handle_mcp_span(
         self,
         span_data: MCPListToolsSpanData,
diff --git a/posthog/ai/otel/_privacy.py b/posthog/ai/otel/_privacy.py
new file mode 100644
index 000000000..5a2114ee5
--- /dev/null
+++ b/posthog/ai/otel/_privacy.py
@@ -0,0 +1,344 @@
+"""Privacy mode for OpenTelemetry spans exported to PostHog."""
+
+import json
+import logging
+import re
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+
+from opentelemetry.attributes import BoundedAttributes
+from opentelemetry.sdk.trace import Event, ReadableSpan
+from opentelemetry.sdk.util import BoundedList
+from opentelemetry.trace.status import Status
+from opentelemetry.util.types import Attributes, AttributeValue
+
+from ..utils import _redact_mcp_tool, _redact_mcp_tool_credentials
+
+if TYPE_CHECKING:
+    from ...client import Client
+
+log = logging.getLogger("posthog")
+
+# Attributes that carry prompts, outputs, tool calls, retrieved documents or error text.
+# Ingestion keeps unmapped attributes as event properties, so this also covers attributes
+# it does not map. Tool definitions ($ai_tools) are not content and stay, as in the SDK
+# wrappers.
+_CONTENT_ATTRIBUTES = frozenset(
+    {
+        # Vercel AI SDK
+        "ai.prompt",
+        "ai.prompt.messages",
+        "ai.request.text",
+        "ai.documents",
+        "ai.response.text",
+        "ai.response.object",
+        "ai.response.toolCalls",
+        "ai.response.reasoning",
+        "ai.response.reasoningDetails",
+        "ai.response.files",
+        "ai.toolCall.args",
+        "ai.toolCall.result",
+        "ai.decision.state",
+        "ai.decision.questions",
+        "ai.decision.answers",
+        "ai.value",
+        "ai.values",
+        "ai.embedding",
+        "ai.embeddings",
+        # OpenTelemetry GenAI semantic conventions
+        "gen_ai.input.messages",
+        "gen_ai.output.messages",
+        "gen_ai.system_instructions",
+        "gen_ai.prompt",
+        "gen_ai.completion",
+        "gen_ai.tool.call.arguments",
+        "gen_ai.tool.call.result",
+        "gen_ai.retrieval.documents",
+        "gen_ai.retrieval.query.text",
+        "gen_ai.memory.query.text",
+        "gen_ai.memory.records",
+        "gen_ai.evaluation.explanation",
+        # Traceloop / OpenLLMetry
+        "traceloop.entity.input",
+        "traceloop.entity.output",
+        "traceloop.prompt.template",
+        "gen_ai.task.input",
+        "gen_ai.task.output",
+        "gen_ai.guardrail.input",
+        "gen_ai.guardrail.output",
+        "gen_ai.guardrail.error.message",
+        "gen_ai.response.revised_prompt",
+        "mcp.response.value",
+        "db.marqo.search.query",
+        # Anthropic
+        "anthropic.tool_result.content",
+        # Pydantic AI / Logfire
+        "pydantic_ai.all_messages",
+        "request_data",
+        "response_data",
+        "model_request_parameters",
+        "final_result",
+        "tool_arguments",
+        "tool_response",
+        "inputs",
+        "prompt",
+        "events",
+        # OpenInference
+        "input.value",
+        "output.value",
+        "llm.function_call",
+        "llm.prompt_template.template",
+        "llm.prompt_template.variables",
+        # Holds request parameters such as Responses `instructions`.
+        "llm.invocation_parameters",
+        "reranker.query",
+        # Langfuse
+        "langfuse.trace.input",
+        "langfuse.trace.output",
+        "langfuse.observation.input",
+        "langfuse.observation.output",
+        "langfuse.observation.status_message",
+        "langfuse.experiment.item.expected_output",
+        # Errors
+        "exception.message",
+        "exception.stacktrace",
+        "error.message",
+    }
+)
+
+_CONTENT_ATTRIBUTE_PREFIXES = (
+    "gen_ai.prompt.",
+    "gen_ai.completion.",
+    "llm.prompts.",
+    "llm.completions.",
+    "llm.input_messages.",
+    "llm.output_messages.",
+    "llm.choices.",
+    "traceloop.prompt.template_variables.",
+)
+
+_CONTENT_ATTRIBUTE_PATTERN = re.compile(
+    "|".join(
+        (
+            r"embedding\.embeddings\.\d+\.embedding\.(text|vector)",
+            r"retrieval\.documents\.\d+\.document\.(content|metadata)",
+            r"reranker\.(input|output)_documents\.\d+\.document\.content",
+            r"(input|output)\.images\.\d+\.image\.url",
+            r"db\.chroma\.(query|get|delete)\.where_document",
+            r"mastra\.[a-z_]+\.(input|output)",
+        )
+    )
+)
+
+# GenAI semantic convention prompt metadata, not content, under the `gen_ai.prompt.` prefix.
+_NON_CONTENT_ATTRIBUTES = frozenset({"gen_ai.prompt.name", "gen_ai.prompt.version"})
+
+_PROVIDER_METADATA_ATTRIBUTE = "ai.response.providerMetadata"
+
+# Tool definitions stay under privacy, but instrumentations serialize remote MCP tools
+# with their credentials into them.
+_TOOL_DEFINITION_ATTRIBUTES = frozenset({"gen_ai.tool.definitions", "ai.prompt.tools"})
+_TOOL_DEFINITION_PATTERN = re.compile(r"llm\.tools\.\d+\.tool\.json_schema")
+
+_EXCEPTION_EVENT_NAME = "exception"
+
+
+def _is_content_attribute(key: str) -> bool:
+    """Whether a span or event attribute can carry prompts, completions, tool data or error text."""
+    if key in _NON_CONTENT_ATTRIBUTES:
+        return False
+    return (
+        key in _CONTENT_ATTRIBUTES
+        or key.startswith(_CONTENT_ATTRIBUTE_PREFIXES)
+        or f"{key}." in _CONTENT_ATTRIBUTE_PREFIXES
+        or _CONTENT_ATTRIBUTE_PATTERN.fullmatch(key) is not None
+    )
+
+
+def _otel_privacy_mode_enabled(privacy_mode: bool, client: Optional["Client"]) -> bool:
+    """Explicit flag, else the given client's `privacy_mode`, else the module-level configuration."""
+    if privacy_mode:
+        return True
+    if client is not None:
+        return getattr(client, "privacy_mode", False) is True
+    # Imported here so later changes to the module-level settings still apply.
+    from ... import default_client, privacy_mode as global_privacy_mode
+
+    return bool(global_privacy_mode) or (
+        getattr(default_client, "privacy_mode", False) is True
+    )
+
+
+def _gateway_cost_only(value: Any) -> Optional[str]:
+    """
+    Provider metadata can carry content, such as Google grounding search queries.
+    Ingestion only reads the Vercel AI Gateway cost from it.
+    """
+    if not isinstance(value, str):
+        return None
+    try:
+        metadata = json.loads(value)
+    except ValueError:
+        return None
+    gateway = metadata.get("gateway") if isinstance(metadata, dict) else None
+    cost = gateway.get("cost") if isinstance(gateway, dict) else None
+    if isinstance(cost, bool) or not isinstance(cost, (int, float, str)):
+        return None
+    return json.dumps({"gateway": {"cost": cost}}, separators=(",", ":"))
+
+
+def _redact_tool_definition_json(value: str, drop_unparseable: bool) -> Optional[str]:
+    try:
+        parsed = json.loads(value)
+    except ValueError:
+        parsed = None
+    if isinstance(parsed, list):
+        redacted = _redact_mcp_tool_credentials(parsed)
+    elif isinstance(parsed, dict):
+        redacted = _redact_mcp_tool(parsed)
+    else:
+        return None if drop_unparseable else value
+    return value if redacted is parsed else json.dumps(redacted)
+
+
+def _redact_tool_definitions(
+    value: Any, drop_unparseable: bool
+) -> Optional[AttributeValue]:
+    """
+    Mask remote MCP credentials in a tool definition attribute. Under privacy mode a
+    value that cannot be parsed is dropped, because it could still hold credentials.
+    """
+    if isinstance(value, str):
+        return _redact_tool_definition_json(value, drop_unparseable)
+    if not isinstance(value, (list, tuple)):
+        return None if drop_unparseable else value
+    redacted: List[Any] = []
+    for item in value:
+        definition = (
+            _redact_tool_definition_json(item, drop_unparseable)
+            if isinstance(item, str)
+            else None
+            if drop_unparseable
+            else item
+        )
+        if definition is not None:
+            redacted.append(definition)
+    if len(redacted) == len(value) and all(a is b for a, b in zip(redacted, value)):
+        return value
+    return redacted
+
+
+def _is_tool_definition_attribute(key: str) -> bool:
+    return (
+        key in _TOOL_DEFINITION_ATTRIBUTES
+        or _TOOL_DEFINITION_PATTERN.fullmatch(key) is not None
+    )
+
+
+def _without_content(attributes: Attributes) -> BoundedAttributes:
+    kept: Dict[str, Any] = {}
+    for key, value in (attributes or {}).items():
+        if _is_content_attribute(key):
+            continue
+        if _is_tool_definition_attribute(key):
+            definitions = _redact_tool_definitions(value, drop_unparseable=True)
+            if definitions is not None:
+                kept[key] = definitions
+            continue
+        if key == _PROVIDER_METADATA_ATTRIBUTE:
+            metadata = _gateway_cost_only(value)
+            if metadata is not None:
+                kept[key] = metadata
+            continue
+        kept[key] = value
+    return BoundedAttributes(attributes=kept)
+
+
+def _without_content_span(span: ReadableSpan) -> ReadableSpan:
+    """
+    Return a copy of ``span`` without content attributes, non-exception events,
+    exception messages and stack traces, or the status description.
+    """
+    # Older OTLP encoders read `.dropped` from these collections, so plain dicts and
+    # lists break export.
+    events = BoundedList.from_seq(
+        None,
+        [
+            Event(
+                name=event.name,
+                attributes=_without_content(event.attributes),
+                timestamp=event.timestamp,
+            )
+            # Other span events (older GenAI semconv messages, framework logs) carry
+            # content and PostHog ingestion only reads exception events.
+            for event in span.events
+            if event.name == _EXCEPTION_EVENT_NAME
+        ],
+    )
+    return ReadableSpan(
+        name=span.name,
+        context=span.get_span_context(),
+        parent=span.parent,
+        resource=span.resource,
+        attributes=_without_content(span.attributes),
+        events=events,
+        links=BoundedList.from_seq(None, span.links),
+        kind=span.kind,
+        status=Status(span.status.status_code),
+        start_time=span.start_time,
+        end_time=span.end_time,
+        instrumentation_scope=span.instrumentation_scope,
+    )
+
+
+def _without_mcp_credentials_span(span: ReadableSpan) -> ReadableSpan:
+    """Return ``span`` with remote MCP credentials masked in its tool definitions."""
+    attributes = dict(span.attributes or {})
+    redacted: Dict[str, Any] = {}
+    for key, value in attributes.items():
+        if not _is_tool_definition_attribute(key):
+            redacted[key] = value
+            continue
+        definitions = _redact_tool_definitions(value, drop_unparseable=False)
+        if definitions is not None:
+            redacted[key] = definitions
+    if redacted.keys() == attributes.keys() and all(
+        redacted[key] is attributes[key] for key in attributes
+    ):
+        return span
+    return ReadableSpan(
+        name=span.name,
+        context=span.get_span_context(),
+        parent=span.parent,
+        resource=span.resource,
+        attributes=BoundedAttributes(attributes=redacted),
+        events=BoundedList.from_seq(None, span.events),
+        links=BoundedList.from_seq(None, span.links),
+        kind=span.kind,
+        status=span.status,
+        start_time=span.start_time,
+        end_time=span.end_time,
+        instrumentation_scope=span.instrumentation_scope,
+    )
+
+
+def _redact_span(span: ReadableSpan, privacy_mode: bool) -> ReadableSpan:
+    """
+    Mask remote MCP credentials in tool definitions on every export, as for
+    ``$ai_tools``. Privacy mode also removes all content.
+    """
+    if privacy_mode:
+        return _without_content_span(span)
+    return _without_mcp_credentials_span(span)
+
+
+def _redacted_spans(
+    spans: Sequence[ReadableSpan], privacy_mode: bool
+) -> List[ReadableSpan]:
+    """Redact each span, dropping only a span whose redaction fails rather than leaking it."""
+    redacted = []
+    for span in spans:
+        try:
+            redacted.append(_redact_span(span, privacy_mode))
+        except Exception:
+            log.debug("Failed to redact span, dropping it", exc_info=True)
+    return redacted
diff --git a/posthog/ai/otel/exporter.py b/posthog/ai/otel/exporter.py
index ec6e387ff..f5d21183c 100644
--- a/posthog/ai/otel/exporter.py
+++ b/posthog/ai/otel/exporter.py
@@ -5,15 +5,19 @@
 SpanExporter (e.g. as an argument to BatchSpanProcessor).
 """
 
-from typing import Optional, Sequence
+from typing import TYPE_CHECKING, Optional, Sequence
 
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
 from ..gateway import warn_if_posthog_ai_gateway_otel_attributes
+from ._privacy import _otel_privacy_mode_enabled, _redacted_spans
 from .spans import DEFAULT_HOST, is_ai_span
 
+if TYPE_CHECKING:
+    from ...client import Client
+
 
 class PostHogTraceExporter(SpanExporter):
     """Span exporter that filters AI spans and forwards them to PostHog.
@@ -41,14 +45,23 @@ def __init__(
         self,
         api_key: str,
         host: str = DEFAULT_HOST,
+        *,
+        privacy_mode: bool = False,
+        client: Optional["Client"] = None,
     ):
         """
         Args:
             api_key: PostHog project API key.
             host: PostHog host URL. Defaults to US cloud.
+            privacy_mode: Drop prompts, completions, tool arguments and results,
+                and error messages from exported spans.
+            client: PostHog client whose ``privacy_mode`` also applies. Without
+                one, the module-level ``posthog.privacy_mode`` setting applies.
         """
         self._api_key = api_key
         self._host = host.rstrip("/")
+        self._privacy_mode = privacy_mode
+        self._client = client
 
         self._exporter = OTLPSpanExporter(
             endpoint=f"{self._host}/i/v0/ai/otel",
@@ -70,6 +83,8 @@ def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
             return SpanExportResult.SUCCESS
         for span in ai_spans:
             warn_if_posthog_ai_gateway_otel_attributes(span.attributes)
+        privacy_mode = _otel_privacy_mode_enabled(self._privacy_mode, self._client)
+        ai_spans = _redacted_spans(ai_spans, privacy_mode)
         return self._exporter.export(ai_spans)
 
     def shutdown(self) -> None:
diff --git a/posthog/ai/otel/processor.py b/posthog/ai/otel/processor.py
index 31073c54b..9c3e73976 100644
--- a/posthog/ai/otel/processor.py
+++ b/posthog/ai/otel/processor.py
@@ -9,7 +9,7 @@
 import os
 import threading
 import weakref
-from typing import Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
@@ -22,8 +22,11 @@
     capture_request_context,
     with_request_context,
 )
+from ._privacy import _otel_privacy_mode_enabled, _redacted_spans
 from .spans import DEFAULT_HOST, is_ai_span
 
+if TYPE_CHECKING:
+    from ...client import Client
 
 log = logging.getLogger("posthog")
 
@@ -89,14 +92,23 @@ def __init__(
         self,
         api_key: str,
         host: str = DEFAULT_HOST,
+        *,
+        privacy_mode: bool = False,
+        client: Optional["Client"] = None,
     ):
         """
         Args:
             api_key: PostHog project API key.
             host: PostHog host URL. Defaults to US cloud.
+            privacy_mode: Drop prompts, completions, tool arguments and results,
+                and error messages from exported spans.
+            client: PostHog client whose ``privacy_mode`` also applies. Without
+                one, the module-level ``posthog.privacy_mode`` setting applies.
         """
         self._api_key = api_key
         self._host = host.rstrip("/")
+        self._privacy_mode = privacy_mode
+        self._client = client
 
         exporter = OTLPSpanExporter(
             endpoint=f"{self._host}/i/v0/ai/otel",
@@ -164,7 +176,9 @@ def on_end(self, span: ReadableSpan) -> None:
                 span = with_request_context(span, captured)
             except Exception:
                 log.debug("Failed to add PostHog context to span", exc_info=True)
-        self._processor.on_end(span)
+        privacy_mode = _otel_privacy_mode_enabled(self._privacy_mode, self._client)
+        for redacted in _redacted_spans([span], privacy_mode):
+            self._processor.on_end(redacted)
 
     def shutdown(self) -> None:
         """Shut down the underlying batch span processor."""
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index 0ae5e9f47..54c601a3d 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -1,5 +1,7 @@
 import asyncio
+import copy
 import logging
+import re
 import time
 import uuid
 from typing import Any, Callable, Dict, List, Optional, Tuple, cast
@@ -502,7 +504,7 @@ def call_llm_and_track_usage(
             http_status = _get_http_status(exc)  # 0 because its likely an SDK error
             error_params = {
                 "$ai_is_error": True,
-                "$ai_error": exc.__str__(),
+                "$ai_error": _format_ai_error(ph_client, posthog_privacy_mode, exc),
             }
             # TODO: Add exception capture for OpenAI/Anthropic/Gemini wrappers when
             # enable_exception_autocapture is True, similar to LangChain callbacks.
@@ -674,7 +676,7 @@ async def call_llm_and_track_usage_async(
             http_status = _get_http_status(exc)  # 0 because its likely an SDK error
             error_params = {
                 "$ai_is_error": True,
-                "$ai_error": exc.__str__(),
+                "$ai_error": _format_ai_error(ph_client, posthog_privacy_mode, exc),
             }
             # TODO: Add exception capture for OpenAI/Anthropic/Gemini wrappers when
             # enable_exception_autocapture is True, similar to LangChain callbacks.
@@ -819,12 +821,229 @@ def finalize_ai_content(value: Any, ph_client: Any = None) -> Any:
     return redact_media(value, ph_client=ph_client)
 
 
+def _privacy_mode_enabled(ph_client: Any, privacy_mode: Optional[bool]) -> bool:
+    return bool(getattr(ph_client, "privacy_mode", False) or privacy_mode)
+
+
 def with_privacy_mode(ph_client: PostHogClient, privacy_mode: bool, value: Any):
-    if getattr(ph_client, "privacy_mode", False) or privacy_mode:
+    if _privacy_mode_enabled(ph_client, privacy_mode):
         return None
     return value
 
 
+_ERROR_CLASS_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_.]{0,127}$")
+_ERROR_PROVIDER_CODE_RE = re.compile(r"^[A-Za-z0-9_.:-]{1,64}$")
+_ERROR_PARAM_RE = re.compile(r"^[A-Za-z0-9_.\[\]-]{1,128}$")
+_ERROR_REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9_.:-]{1,128}$")
+_ERROR_CODE_FIELDS = ("code", "type", "status")
+_ERROR_STATUS_FIELDS = ("status_code", "status", "code")
+_MAX_ERROR_CAUSES = 3
+_FALLBACK_ERROR_CLASS_NAME = "Exception"
+
+
+def _read_error_field(source: Any, key: str) -> Any:
+    if source is None:
+        return None
+    try:
+        if isinstance(source, dict):
+            return source.get(key)
+        return getattr(source, key, None)
+    except Exception:
+        return None
+
+
+def _matching(value: object, grammar: "re.Pattern[str]") -> Optional[str]:
+    if isinstance(value, str) and grammar.fullmatch(value):
+        return value
+    return None
+
+
+def _first_matching(values: List[Any], grammar: "re.Pattern[str]") -> Optional[str]:
+    for value in values:
+        match = _matching(value, grammar)
+        if match is not None:
+            return match
+    return None
+
+
+def _error_class_name(name: object) -> str:
+    return _matching(name, _ERROR_CLASS_NAME_RE) or _FALLBACK_ERROR_CLASS_NAME
+
+
+def _error_http_status(exc: BaseException) -> Optional[int]:
+    for key in _ERROR_STATUS_FIELDS:
+        value = _read_error_field(exc, key)
+        if (
+            isinstance(value, int)
+            and not isinstance(value, bool)
+            and 100 <= value <= 599
+        ):
+            return value
+    return None
+
+
+def _error_body(exc: BaseException) -> Any:
+    # Anthropic nests the detail as `{"type": "error", "error": {"type": ...}}`.
+    body = _read_error_field(exc, "body")
+    inner = _read_error_field(body, "error")
+    return inner if isinstance(inner, dict) else body
+
+
+def _error_cause_names(exc: BaseException) -> List[str]:
+    names: List[str] = []
+    cause = exc.__cause__ or exc.__context__
+    while cause is not None and len(names) < _MAX_ERROR_CAUSES:
+        names.append(_error_class_name(type(cause).__name__))
+        cause = cause.__cause__ or cause.__context__
+    return names
+
+
+def _format_error_summary(
+    name: object,
+    *,
+    status: Optional[int] = None,
+    codes: Optional[List[str]] = None,
+    param: Optional[str] = None,
+    request_id: Optional[str] = None,
+    causes: Optional[List[str]] = None,
+) -> str:
+    """Render the privacy-safe `$ai_error` format shared with the JS SDK."""
+    summary = _error_class_name(name)
+    if status is not None:
+        summary += f": {status}"
+    for code in dict.fromkeys(codes or []):
+        summary += f" {code}"
+    if param is not None:
+        summary += f" param={param}"
+    if request_id is not None:
+        summary += f" request_id={request_id}"
+    if causes:
+        summary += f" (caused by {', '.join(causes)})"
+    return summary
+
+
+def _summarize_error_for_privacy(exc: BaseException) -> str:
+    """
+    Describe an exception for `$ai_error` without its message, traceback or
+    arbitrary attributes, which routinely echo prompts and model output.
+    Only structured fields that pass a strict grammar are kept.
+    """
+    try:
+        sources = [exc, _error_body(exc)]
+        codes = [
+            code
+            for source in sources
+            for key in _ERROR_CODE_FIELDS
+            if (
+                code := _matching(
+                    _read_error_field(source, key), _ERROR_PROVIDER_CODE_RE
+                )
+            )
+            is not None
+        ]
+        return _format_error_summary(
+            type(exc).__name__,
+            status=_error_http_status(exc),
+            codes=codes,
+            param=_first_matching(
+                [_read_error_field(source, "param") for source in sources],
+                _ERROR_PARAM_RE,
+            ),
+            request_id=_matching(
+                _read_error_field(exc, "request_id"), _ERROR_REQUEST_ID_RE
+            ),
+            causes=_error_cause_names(exc),
+        )
+    except Exception:
+        return _FALLBACK_ERROR_CLASS_NAME
+
+
+_PRIVACY_SAFE_MESSAGE_ATTR = "_posthog_privacy_safe_message"
+
+
+def _with_privacy_safe_message(exc: BaseException) -> BaseException:
+    """Mark an SDK-built exception whose message is fixed text, so privacy mode keeps it."""
+    setattr(exc, _PRIVACY_SAFE_MESSAGE_ATTR, True)
+    return exc
+
+
+def _format_ai_error(
+    ph_client: Any,
+    privacy_mode: Optional[bool],
+    exc: BaseException,
+    describe: Callable[[BaseException], str] = str,
+) -> str:
+    """The `$ai_error` value for `exc`, summarized when privacy mode is on."""
+    if _privacy_mode_enabled(ph_client, privacy_mode) and (
+        getattr(exc, _PRIVACY_SAFE_MESSAGE_ATTR, False) is not True
+    ):
+        return _summarize_error_for_privacy(exc)
+    return describe(exc)
+
+
+_MCP_TOOL_CREDENTIAL_FIELDS = ("headers", "authorization")
+_REDACTED_MCP_CREDENTIAL = "[REDACTED]"
+
+# Vercel AI SDK provider tools that configure a remote MCP server, keyed by their `id`.
+# They reach this SDK through OpenTelemetry tool definition attributes.
+_MCP_PROVIDER_TOOL_IDS = frozenset({"openai.mcp", "xai.mcp", "google.mcp_server"})
+
+
+def _without_mcp_credentials(config: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        key: (
+            _REDACTED_MCP_CREDENTIAL
+            if key in _MCP_TOOL_CREDENTIAL_FIELDS and value is not None
+            else value
+        )
+        for key, value in config.items()
+    }
+
+
+def _is_mcp_provider_tool(tool: Dict[str, Any]) -> bool:
+    return (
+        tool.get("type") in ("provider", "provider-defined")
+        and tool.get("id") in _MCP_PROVIDER_TOOL_IDS
+        and isinstance(tool.get("args"), dict)
+    )
+
+
+def _redact_mcp_tool(tool: Any) -> Any:
+    if not isinstance(tool, dict):
+        if getattr(tool, "type", None) != "mcp":
+            return tool
+        model_dump = getattr(tool, "model_dump", None)
+        if callable(model_dump):
+            return _redact_mcp_tool(model_dump())
+        try:
+            redacted = copy.copy(tool)
+            for field in _MCP_TOOL_CREDENTIAL_FIELDS:
+                if getattr(tool, field, None) is not None:
+                    setattr(redacted, field, _REDACTED_MCP_CREDENTIAL)
+            return redacted
+        except Exception:
+            return {"type": "mcp"}
+    if tool.get("type") == "mcp":
+        return _without_mcp_credentials(tool)
+    if _is_mcp_provider_tool(tool):
+        return {**tool, "args": _without_mcp_credentials(tool["args"])}
+    return tool
+
+
+def _redact_mcp_tool_credentials(tools: Any) -> Any:
+    """
+    Mask the `headers` and `authorization` of MCP tool definitions, which carry
+    credentials for the remote server. Returns copies; the caller's tools are
+    left untouched.
+    """
+    if not isinstance(tools, (list, tuple)):
+        return tools
+    redacted = [_redact_mcp_tool(tool) for tool in tools]
+    if all(new is old for new, old in zip(redacted, tools)):
+        return tools
+    return redacted
+
+
 def capture_streaming_event(
     ph_client: PostHogClient,
     event_data: StreamingEventData,
@@ -887,7 +1106,14 @@ def capture_streaming_event(
         "$ai_base_url": str(event_data["base_url"]),
         **(event_data.get("properties") or {}),
         **(
-            {"$ai_is_error": True, "$ai_error": str(error)} if error is not None else {}
+            {
+                "$ai_is_error": True,
+                "$ai_error": _format_ai_error(
+                    ph_client, event_data["privacy_mode"], error
+                ),
+            }
+            if error is not None
+            else {}
         ),
     }
 
diff --git a/posthog/test/ai/gemini/test_gemini_parity.py b/posthog/test/ai/gemini/test_gemini_parity.py
index de9f9b82f..e4605e49c 100644
--- a/posthog/test/ai/gemini/test_gemini_parity.py
+++ b/posthog/test/ai/gemini/test_gemini_parity.py
@@ -36,7 +36,19 @@ def test_sync_and_async_clients_preserve_explicit_empty_api_key(
 
 
 @pytest.mark.parametrize("client_class", [Client, AsyncClient])
-def test_sync_and_async_clients_merge_posthog_defaults_without_mutation(client_class):
+@pytest.mark.parametrize(
+    "default_privacy_mode, call_privacy_mode, expected_privacy_mode",
+    [
+        (True, False, True),
+        (True, None, True),
+        (False, True, True),
+        (False, None, False),
+        (False, False, False),
+    ],
+)
+def test_sync_and_async_clients_merge_posthog_defaults_without_mutation(
+    client_class, default_privacy_mode, call_privacy_mode, expected_privacy_mode
+):
     default_properties = {"shared": "default", "default-only": True}
 
     with patch.object(google_genai, "Client"):
@@ -45,7 +57,7 @@ def test_sync_and_async_clients_merge_posthog_defaults_without_mutation(client_c
             posthog_client=MagicMock(),
             posthog_distinct_id="default-id",
             posthog_properties=default_properties,
-            posthog_privacy_mode=True,
+            posthog_privacy_mode=default_privacy_mode,
             posthog_groups={"organization": "default-org"},
         )
 
@@ -53,7 +65,7 @@ def test_sync_and_async_clients_merge_posthog_defaults_without_mutation(client_c
         None,
         "",
         {"shared": "call", "call-only": True},
-        False,
+        call_privacy_mode,
         None,
     )
 
@@ -61,7 +73,7 @@ def test_sync_and_async_clients_merge_posthog_defaults_without_mutation(client_c
         "default-id",
         "",
         {"shared": "call", "default-only": True, "call-only": True},
-        False,
+        expected_privacy_mode,
         {"organization": "default-org"},
     )
     assert default_properties == {"shared": "default", "default-only": True}
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index b33e154fc..4c4de1be2 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -2716,16 +2716,26 @@ def failing_span(_):
     assert span_props["$ai_error"] == "ValueError: test error"
 
 
-def test_exception_autocapture_disabled_does_not_capture():
-    """Test that capture_exception is NOT called when autocapture is disabled."""
+@pytest.mark.parametrize(
+    "autocapture, client_privacy_mode, handler_privacy_mode, expected_error",
+    [
+        (False, False, False, "ValueError: test error"),
+        (True, True, False, "ValueError"),
+        (True, False, True, "ValueError"),
+    ],
+)
+def test_exception_autocapture_disabled_does_not_capture(
+    autocapture, client_privacy_mode, handler_privacy_mode, expected_error
+):
+    """capture_exception is skipped when autocapture is off or privacy mode is on."""
     mock_client = MagicMock()
-    mock_client.privacy_mode = False
-    mock_client.enable_exception_autocapture = False
+    mock_client.privacy_mode = client_privacy_mode
+    mock_client.enable_exception_autocapture = autocapture
 
     def failing_span(_):
         raise ValueError("test error")
 
-    callbacks = [CallbackHandler(mock_client)]
+    callbacks = [CallbackHandler(mock_client, privacy_mode=handler_privacy_mode)]
     chain = RunnableLambda(failing_span)
 
     try:
@@ -2746,7 +2756,7 @@ def failing_span(_):
 
     span_props = span_calls[0][1]["properties"]
     assert "$exception_event_id" not in span_props
-    assert span_props["$ai_error"] == "ValueError: test error"
+    assert span_props["$ai_error"] == expected_error
 
 
 def test_exception_autocapture_on_llm_generation_error(mock_client):
diff --git a/posthog/test/ai/langchain/test_middleware.py b/posthog/test/ai/langchain/test_middleware.py
index ed68bca85..f01dd91c2 100644
--- a/posthog/test/ai/langchain/test_middleware.py
+++ b/posthog/test/ai/langchain/test_middleware.py
@@ -641,7 +641,7 @@ def handler(inner_request: ToolCallRequest) -> ToolMessage:
     assert actual is response
     span = _event(client, "$ai_span")["properties"]
     assert span["$ai_is_error"] is True
-    assert secret not in str(span.get("$ai_error", ""))
+    assert span["$ai_error"] == "RuntimeError: Tool returned an error"
 
 
 @pytest.mark.parametrize("asynchronous", [False, True])
diff --git a/posthog/test/ai/test_privacy_mode.py b/posthog/test/ai/test_privacy_mode.py
new file mode 100644
index 000000000..065c79b0d
--- /dev/null
+++ b/posthog/test/ai/test_privacy_mode.py
@@ -0,0 +1,800 @@
+"""Privacy mode across the AI integrations: nothing user-authored may leave the process."""
+
+import json
+from types import SimpleNamespace
+from typing import Any, Callable, Dict, Iterator, List
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from posthog.ai.utils import (
+    _REDACTED_MCP_CREDENTIAL,
+    extract_available_tool_calls,
+    _summarize_error_for_privacy,
+)
+from posthog.client import Client
+from posthog.test.test_utils import FAKE_TEST_API_KEY
+
+CANARY = "CANARY_7f3a"
+
+
+class _Parsed(BaseModel):
+    answer: int
+
+
+def _validation_error() -> ValidationError:
+    try:
+        _Parsed.model_validate_json(json.dumps({"answer": CANARY}))
+    except ValidationError as exc:
+        return exc
+    raise AssertionError("validation unexpectedly passed")
+
+
+def _httpx_response(status: int) -> Any:
+    import httpx
+
+    return httpx.Response(
+        status,
+        request=httpx.Request("POST", "https://api.example.com/v1/run"),
+        headers={"x-request-id": "req_123", "request-id": "req_123"},
+    )
+
+
+def _openai_bad_request() -> Exception:
+    import openai
+
+    return openai.BadRequestError(
+        f"Error code: 400 - {CANARY}",
+        response=_httpx_response(400),
+        body={
+            "message": f"echoed request: {CANARY}",
+            "type": "invalid_request_error",
+            "param": "messages[3].content",
+            "code": None,
+        },
+    )
+
+
+def _anthropic_bad_request() -> Exception:
+    import anthropic
+
+    return anthropic.BadRequestError(
+        f"echoed request: {CANARY}",
+        response=_httpx_response(400),
+        body={
+            "type": "error",
+            "error": {"type": "invalid_request_error", "message": CANARY},
+        },
+    )
+
+
+def _gemini_client_error() -> Exception:
+    from google.genai import errors
+
+    return errors.ClientError(
+        400,
+        {"error": {"code": 400, "message": CANARY, "status": "INVALID_ARGUMENT"}},
+    )
+
+
+class _ProviderShapedError(Exception):
+    def __init__(self, **fields: Any) -> None:
+        super().__init__(CANARY)
+        self.__dict__.update(fields)
+
+
+class _UnreadableError(Exception):
+    @property
+    def status_code(self) -> int:
+        raise RuntimeError(CANARY)
+
+
+def _chained_error(depth: int) -> BaseException:
+    error_types = [KeyError, ValueError, TypeError, LookupError, RuntimeError]
+    error: BaseException = error_types[0](CANARY)
+    for error_type in error_types[1 : depth + 1]:
+        try:
+            try:
+                raise error
+            except BaseException as cause:
+                raise error_type(CANARY) from cause
+        except BaseException as chained:
+            error = chained
+    return error
+
+
+def _implicit_context_error() -> BaseException:
+    try:
+        try:
+            raise KeyError(CANARY)
+        except KeyError:
+            raise ValueError(CANARY)
+    except ValueError as exc:
+        return exc
+
+
+@pytest.mark.parametrize(
+    "make_error, expected",
+    [
+        pytest.param(
+            _openai_bad_request,
+            "BadRequestError: 400 invalid_request_error param=messages[3].content request_id=req_123",
+            id="openai",
+        ),
+        pytest.param(
+            _anthropic_bad_request,
+            "BadRequestError: 400 invalid_request_error request_id=req_123",
+            id="anthropic",
+        ),
+        pytest.param(
+            _gemini_client_error, "ClientError: 400 INVALID_ARGUMENT", id="gemini"
+        ),
+        pytest.param(_validation_error, "ValidationError", id="pydantic"),
+        pytest.param(
+            lambda: _ProviderShapedError(
+                code="invalid_request_error",
+                type="invalid_request_error",
+                param="x",
+            ),
+            "_ProviderShapedError invalid_request_error param=x",
+            id="no-status-and-duplicate-codes",
+        ),
+        pytest.param(
+            lambda: _ProviderShapedError(status_code=503, code="overloaded"),
+            "_ProviderShapedError: 503 overloaded",
+            id="generic-status-and-code",
+        ),
+        pytest.param(
+            lambda: _ProviderShapedError(
+                status_code=700,
+                code=f"{CANARY} with spaces",
+                type="x" * 65,
+                param="messages[0] content",
+                request_id="req/123",
+            ),
+            "_ProviderShapedError",
+            id="grammar-rejects-every-field",
+        ),
+        pytest.param(
+            lambda: _ProviderShapedError(status_code=True, status="429"),
+            "_ProviderShapedError 429",
+            id="bool-and-string-status-are-not-http-status",
+        ),
+        pytest.param(
+            lambda: type("Bad Name", (Exception,), {})(CANARY),
+            "Exception",
+            id="class-name-rejected",
+        ),
+        pytest.param(
+            lambda: _UnreadableError(CANARY), "_UnreadableError", id="raising-property"
+        ),
+        pytest.param(
+            lambda: _chained_error(2),
+            "TypeError (caused by ValueError, KeyError)",
+            id="explicit-cause",
+        ),
+        pytest.param(
+            _implicit_context_error,
+            "ValueError (caused by KeyError)",
+            id="implicit-context",
+        ),
+        pytest.param(
+            lambda: _chained_error(4),
+            "RuntimeError (caused by LookupError, TypeError, ValueError)",
+            id="cause-chain-capped-at-three",
+        ),
+    ],
+)
+def test_summarize_error_for_privacy(
+    make_error: Callable[[], BaseException], expected: str
+) -> None:
+    summary = _summarize_error_for_privacy(make_error())
+
+    assert summary == expected
+    assert CANARY not in summary
+
+
+@pytest.mark.parametrize("provider", ["openai", "anthropic", "gemini"])
+def test_mcp_tool_credentials_are_masked_without_mutating_caller_tools(
+    provider: str,
+) -> None:
+    from openai.types.responses.tool import Mcp
+
+    mcp_dict = {
+        "type": "mcp",
+        "server_label": "docs",
+        "server_url": "https://mcp.example.com",
+        "headers": {"Authorization": f"Bearer {CANARY}"},
+        "authorization": CANARY,
+    }
+    mcp_model = Mcp(
+        type="mcp",
+        server_label="docs",
+        server_url="https://mcp.example.com",
+        headers={"X-Api-Key": CANARY},
+    )
+    mcp_object = SimpleNamespace(type="mcp", headers={"X-Api-Key": CANARY})
+    function_tool = {"type": "function", "name": "lookup", "headers": "kept"}
+    tools = [mcp_dict, mcp_model, mcp_object, function_tool]
+    kwargs: Dict[str, Any] = (
+        {"config": SimpleNamespace(tools=tools)}
+        if provider == "gemini"
+        else {"tools": tools}
+    )
+
+    captured = extract_available_tool_calls(provider, kwargs)
+
+    assert captured[0] == {
+        **mcp_dict,
+        "headers": _REDACTED_MCP_CREDENTIAL,
+        "authorization": _REDACTED_MCP_CREDENTIAL,
+    }
+    assert captured[1]["headers"] == _REDACTED_MCP_CREDENTIAL
+    assert captured[1]["authorization"] is None
+    assert captured[1]["server_url"] == "https://mcp.example.com"
+    assert captured[2].headers == _REDACTED_MCP_CREDENTIAL
+    assert captured[3] is function_tool
+    assert CANARY not in json.dumps(captured, default=str)
+    assert tools == [mcp_dict, mcp_model, mcp_object, function_tool]
+    assert mcp_dict["headers"] == {"Authorization": f"Bearer {CANARY}"}
+    assert mcp_model.headers == {"X-Api-Key": CANARY}
+    assert mcp_object.headers == {"X-Api-Key": CANARY}
+
+
+@pytest.fixture
+def private_client() -> Iterator[Client]:
+    client = Client(
+        FAKE_TEST_API_KEY, privacy_mode=True, enable_exception_autocapture=True
+    )
+    client._enqueue = MagicMock()  # type: ignore[method-assign]
+    yield client
+    if client.exception_capture:
+        client.exception_capture.close()
+
+
+def _sent_events(client: Client) -> List[Dict[str, Any]]:
+    return [call.args[0] for call in client._enqueue.call_args_list]  # type: ignore[attr-defined]
+
+
+def _assert_no_canary(client: Client) -> List[Dict[str, Any]]:
+    events = _sent_events(client)
+    assert events
+    assert any(event["properties"].get("$ai_is_error") for event in events)
+    assert CANARY not in json.dumps(events, default=str)
+    return events
+
+
+def _function_tool() -> Dict[str, Any]:
+    return {
+        "type": "function",
+        "function": {"name": "lookup", "parameters": {"type": "object"}},
+    }
+
+
+@pytest.mark.parametrize(
+    "resource, method",
+    [("chat_create", "create"), ("chat_parse", "parse"), ("responses", "create")],
+)
+def test_openai_privacy_mode_sends_no_content(
+    private_client: Client, resource: str, method: str
+) -> None:
+    import openai
+
+    from posthog.ai.openai import OpenAI
+
+    error = _validation_error() if resource == "chat_parse" else _openai_bad_request()
+    target = (
+        openai.resources.responses.Responses
+        if resource == "responses"
+        else openai.resources.chat.completions.Completions
+    )
+    client = OpenAI(posthog_client=private_client, api_key="test-key")
+    call = (
+        getattr(client.responses, method)
+        if resource == "responses"
+        else getattr(client.chat.completions, method)
+    )
+    request: Dict[str, Any] = (
+        {
+            "input": f"user prompt {CANARY}",
+            "instructions": CANARY,
+            "tools": [
+                {
+                    "type": "mcp",
+                    "server_label": "docs",
+                    "headers": {"Authorization": CANARY},
+                }
+            ],
+        }
+        if resource == "responses"
+        else {
+            "messages": [{"role": "user", "content": f"user prompt {CANARY}"}],
+            "tools": [_function_tool()],
+        }
+    )
+
+    with patch.object(target, method, side_effect=error):
+        with pytest.raises(type(error)):
+            call(model="gpt-4o", **request)
+
+    _assert_no_canary(private_client)
+
+
+def test_anthropic_privacy_mode_sends_no_content(private_client: Client) -> None:
+    from posthog.ai.anthropic import Anthropic
+
+    client = Anthropic(api_key="test-key", posthog_client=private_client)
+
+    with patch(
+        "anthropic.resources.Messages.create", side_effect=_anthropic_bad_request()
+    ):
+        with pytest.raises(Exception):
+            client.messages.create(
+                model="claude-sonnet-4-5",
+                max_tokens=16,
+                system=CANARY,
+                messages=[{"role": "user", "content": f"user prompt {CANARY}"}],
+            )
+
+    events = _assert_no_canary(private_client)
+    assert (
+        events[0]["properties"]["$ai_error"]
+        == "BadRequestError: 400 invalid_request_error request_id=req_123"
+    )
+
+
+@pytest.mark.parametrize("method", ["generate_content", "embed_content"])
+def test_gemini_privacy_mode_sends_no_content(
+    private_client: Client, method: str
+) -> None:
+    google_genai = pytest.importorskip("google.genai")
+    from posthog.ai.gemini import Client as GeminiClient
+
+    error = (
+        _validation_error() if method == "generate_content" else _gemini_client_error()
+    )
+    client = GeminiClient(api_key="test-key", posthog_client=private_client)
+
+    with patch.object(google_genai.models.Models, method, side_effect=error):
+        with pytest.raises(type(error)):
+            getattr(client.models, method)(
+                model="gemini-2.5-flash",
+                contents=[f"user prompt {CANARY}"],
+                posthog_privacy_mode=False,
+            )
+
+    _assert_no_canary(private_client)
+
+
+def test_langchain_privacy_mode_sends_no_content_or_exception_event(
+    private_client: Client,
+) -> None:
+    import uuid
+
+    from langchain_core.exceptions import OutputParserException
+    from langchain_core.messages import HumanMessage
+    from langchain_core.prompts import ChatPromptTemplate
+    from langchain_core.runnables import RunnableLambda
+
+    from posthog.ai.langchain import CallbackHandler
+
+    callbacks = CallbackHandler(private_client)
+
+    def failing_parser(_: Any) -> None:
+        raise OutputParserException(
+            f"Could not parse output: {CANARY}", llm_output=CANARY
+        )
+
+    chain = ChatPromptTemplate.from_messages([("user", CANARY)]) | RunnableLambda(
+        failing_parser
+    )
+    with pytest.raises(OutputParserException):
+        chain.invoke({}, config={"callbacks": [callbacks]})
+
+    run_id = uuid.uuid4()
+    callbacks.on_chat_model_start(
+        {"kwargs": {"model_name": "gpt-4o"}},
+        [[HumanMessage(content=CANARY)]],
+        run_id=run_id,
+        invocation_params={
+            "tools": [
+                _function_tool(),
+                {"type": "mcp", "server_label": "docs", "headers": {"k": CANARY}},
+            ]
+        },
+    )
+    callbacks.on_llm_error(_openai_bad_request(), run_id=run_id)
+
+    events = _assert_no_canary(private_client)
+    assert "$exception" not in {event["event"] for event in events}
+    errors = {event["properties"].get("$ai_error") for event in events}
+    assert "OutputParserException" in errors
+
+
+def test_openai_agents_privacy_mode_sends_no_content(private_client: Client) -> None:
+    pytest.importorskip("agents")
+    from agents.tracing.span_data import (
+        FunctionSpanData,
+        GenerationSpanData,
+        SpeechSpanData,
+        TranscriptionSpanData,
+    )
+
+    from posthog.ai.openai_agents import PostHogTracingProcessor
+
+    processor = PostHogTracingProcessor(client=private_client, distinct_id="user")
+    trace = MagicMock(
+        trace_id="trace_1", group_id=None, metadata={"customer_note": CANARY}
+    )
+    trace.name = "workflow"
+    processor.on_trace_start(trace)
+
+    span_datas = [
+        GenerationSpanData(
+            input=[{"role": "user", "content": CANARY}],
+            output=[{"role": "assistant", "content": CANARY}],
+            model="gpt-4o",
+        ),
+        FunctionSpanData(name="lookup", input=CANARY, output=CANARY),
+        TranscriptionSpanData(
+            input="AAAA",
+            input_format="pcm",
+            output=CANARY,
+            model="gpt-4o-transcribe",
+            model_config={"prompt": CANARY, "language": "en"},
+        ),
+        SpeechSpanData(
+            input=CANARY,
+            output=None,
+            output_format="pcm",
+            model="gpt-4o-mini-tts",
+            model_config={"instructions": CANARY, "voice": "alloy"},
+        ),
+    ]
+    for index, span_data in enumerate(span_datas):
+        span = MagicMock(
+            trace_id="trace_1",
+            span_id=f"span_{index}",
+            parent_id=None,
+            started_at=None,
+            ended_at=None,
+            span_data=span_data,
+            error={"message": f"Tool failed: {CANARY}", "data": {"detail": CANARY}},
+        )
+        processor.on_span_start(span)
+        processor.on_span_end(span)
+    processor.on_trace_end(trace)
+
+    events = _assert_no_canary(private_client)
+    audio_configs = [
+        event["properties"]["model_config"]
+        for event in events
+        if "model_config" in event["properties"]
+    ]
+    assert audio_configs == [
+        {"prompt": None, "language": "en"},
+        {"instructions": None, "voice": "alloy"},
+    ]
+
+
+_KEPT_OTEL_ATTRIBUTES: Dict[str, Any] = {
+    "gen_ai.request.model": "gpt-4o",
+    "gen_ai.usage.input_tokens": 3,
+    "gen_ai.tool.definitions": '[{"name": "lookup"}]',
+    "llm.request.functions.0.name": "lookup",
+    "ai.prompt.tools": ('{"name": "lookup"}',),
+    "ai.prompt.toolChoice": '{"type": "auto"}',
+    "gen_ai.prompt.name": "support-reply",
+    "gen_ai.prompt.version": "3",
+}
+
+
+_MCP_OTEL_TOOL = {
+    "type": "mcp",
+    "server_label": "docs",
+    "headers": {"Authorization": CANARY},
+    "authorization": CANARY,
+}
+
+_VERCEL_MCP_OTEL_TOOL = {
+    "type": "provider",
+    "id": "openai.mcp",
+    "name": "docs",
+    "args": {"serverUrl": "https://mcp.example.com", "authorization": CANARY},
+}
+
+_MCP_OTEL_TOOL_ATTRIBUTES: Dict[str, Any] = {
+    "ai.prompt.tools": (
+        '{"name": "lookup"}',
+        json.dumps(_MCP_OTEL_TOOL),
+        json.dumps(_VERCEL_MCP_OTEL_TOOL),
+    ),
+    "llm.tools.0.tool.json_schema": json.dumps(_MCP_OTEL_TOOL),
+    "llm.tools.1.tool.json_schema": f"not json {CANARY}",
+}
+
+_REDACTED_MCP_OTEL_TOOL = json.dumps(
+    {
+        **_MCP_OTEL_TOOL,
+        "headers": _REDACTED_MCP_CREDENTIAL,
+        "authorization": _REDACTED_MCP_CREDENTIAL,
+    }
+)
+
+_REDACTED_MCP_OTEL_TOOL_ATTRIBUTES: Dict[str, Any] = {
+    "ai.prompt.tools": (
+        '{"name": "lookup"}',
+        _REDACTED_MCP_OTEL_TOOL,
+        json.dumps(
+            {
+                **_VERCEL_MCP_OTEL_TOOL,
+                "args": {
+                    "serverUrl": "https://mcp.example.com",
+                    "authorization": _REDACTED_MCP_CREDENTIAL,
+                },
+            }
+        ),
+    ),
+    "llm.tools.0.tool.json_schema": _REDACTED_MCP_OTEL_TOOL,
+}
+
+
+def _emit_canary_span(provider: Any, provider_metadata: str) -> None:
+    from opentelemetry.trace import Status, StatusCode
+
+    tracer = provider.get_tracer("test")
+    content_attributes = {
+        "gen_ai.input.messages": json.dumps([{"role": "user", "content": CANARY}]),
+        "gen_ai.output.messages": CANARY,
+        "gen_ai.system_instructions": CANARY,
+        "gen_ai.tool.call.arguments": CANARY,
+        "gen_ai.tool.call.result": CANARY,
+        "gen_ai.prompt.0.content": CANARY,
+        "gen_ai.completion.0.content": CANARY,
+        "traceloop.entity.input": CANARY,
+        "traceloop.entity.output": CANARY,
+        "ai.prompt": CANARY,
+        "ai.prompt.messages": CANARY,
+        "ai.response.text": CANARY,
+        "ai.response.object": CANARY,
+        "ai.response.toolCalls": CANARY,
+        "ai.response.reasoning": CANARY,
+        "ai.toolCall.args": CANARY,
+        "ai.toolCall.result": CANARY,
+        "ai.value": CANARY,
+        "ai.values": [CANARY],
+        "pydantic_ai.all_messages": CANARY,
+        "final_result": CANARY,
+        "tool_arguments": CANARY,
+        "tool_response": CANARY,
+        "request_data": CANARY,
+        "response_data": CANARY,
+        "anthropic.tool_result.content": CANARY,
+        "events": CANARY,
+        "error.message": CANARY,
+        "input.value": CANARY,
+        "output.value": CANARY,
+        "llm.input_messages.0.message.content": CANARY,
+        "llm.output_messages.0.message.content": CANARY,
+        "llm.choices.0.completion.text": CANARY,
+        "llm.function_call": CANARY,
+        "llm.invocation_parameters": json.dumps({"instructions": CANARY}),
+        "llm.prompt_template.template": CANARY,
+        "llm.prompt_template.variables": CANARY,
+        "embedding.embeddings.0.embedding.text": CANARY,
+        "embedding.embeddings.0.embedding.vector": (0.12, 0.34),
+        "llm.prompts": CANARY,
+        "llm.input_messages": CANARY,
+        "ai.request.text": CANARY,
+        "ai.documents": CANARY,
+        "ai.response.reasoningDetails": CANARY,
+        "ai.response.files": CANARY,
+        "ai.decision.state": CANARY,
+        "ai.decision.questions": CANARY,
+        "ai.decision.answers": CANARY,
+        "ai.embedding": CANARY,
+        "ai.embeddings": CANARY,
+        "gen_ai.prompt.variable.customer": CANARY,
+        "gen_ai.retrieval.documents": CANARY,
+        "gen_ai.retrieval.query.text": CANARY,
+        "gen_ai.memory.query.text": CANARY,
+        "gen_ai.memory.records": CANARY,
+        "gen_ai.evaluation.explanation": CANARY,
+        "gen_ai.task.input": CANARY,
+        "gen_ai.task.output": CANARY,
+        "gen_ai.guardrail.input": CANARY,
+        "gen_ai.guardrail.output": CANARY,
+        "gen_ai.guardrail.error.message": CANARY,
+        "gen_ai.response.revised_prompt": CANARY,
+        "mcp.response.value": CANARY,
+        "traceloop.prompt.template": CANARY,
+        "traceloop.prompt.template_variables.customer": CANARY,
+        "db.marqo.search.query": CANARY,
+        "db.chroma.query.where_document": CANARY,
+        "llm.completions.0.content": CANARY,
+        "retrieval.documents.0.document.content": CANARY,
+        "retrieval.documents.0.document.metadata": CANARY,
+        "reranker.query": CANARY,
+        "reranker.input_documents.0.document.content": CANARY,
+        "reranker.output_documents.0.document.content": CANARY,
+        "input.images.0.image.url": CANARY,
+        "output.images.0.image.url": CANARY,
+        "model_request_parameters": CANARY,
+        "inputs": CANARY,
+        "prompt": CANARY,
+        "langfuse.trace.input": CANARY,
+        "langfuse.trace.output": CANARY,
+        "langfuse.observation.input": CANARY,
+        "langfuse.observation.output": CANARY,
+        "langfuse.observation.status_message": CANARY,
+        "langfuse.experiment.item.expected_output": CANARY,
+        "mastra.agent_run.input": CANARY,
+        "mastra.agent_run.output": CANARY,
+    }
+    with tracer.start_as_current_span(
+        "gen_ai.chat",
+        attributes={
+            **_KEPT_OTEL_ATTRIBUTES,
+            **_MCP_OTEL_TOOL_ATTRIBUTES,
+            **content_attributes,
+            "ai.response.providerMetadata": provider_metadata,
+        },
+    ) as span:
+        span.add_event("gen_ai.content.prompt", {"gen_ai.prompt": CANARY})
+        span.record_exception(ValueError(CANARY))
+        span.set_status(Status(StatusCode.ERROR, CANARY))
+
+
+def _export_spans(
+    integration: str, options: Dict[str, Any], emit: Callable[[Any], None]
+) -> List[Any]:
+    from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
+    from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+    from posthog.ai.otel import PostHogSpanProcessor, PostHogTraceExporter
+
+    exported: List[ReadableSpan] = []
+    provider = TracerProvider()
+    with (
+        patch("posthog.ai.otel.processor.OTLPSpanExporter"),
+        patch("posthog.ai.otel.processor.BatchSpanProcessor") as batch,
+        patch("posthog.ai.otel.exporter.OTLPSpanExporter") as otlp,
+    ):
+        batch.return_value.on_end.side_effect = exported.append
+        otlp.return_value.export.side_effect = exported.extend
+        if integration == "processor":
+            provider.add_span_processor(
+                PostHogSpanProcessor(api_key="phc_test", **options)
+            )
+        else:
+            provider.add_span_processor(
+                SimpleSpanProcessor(PostHogTraceExporter(api_key="phc_test", **options))
+            )
+        emit(provider)
+    return exported
+
+
+@pytest.mark.parametrize(
+    "provider_metadata, kept_provider_metadata",
+    [
+        (
+            json.dumps(
+                {
+                    "gateway": {"cost": 0.0012, "routing": CANARY},
+                    "google": {"groundingMetadata": CANARY},
+                }
+            ),
+            {"ai.response.providerMetadata": '{"gateway":{"cost":0.0012}}'},
+        ),
+        (json.dumps({"google": {"groundingMetadata": CANARY}}), {}),
+        (f"not json {CANARY}", {}),
+    ],
+    ids=["gateway_cost", "no_gateway_cost", "unparseable"],
+)
+@pytest.mark.parametrize("integration", ["processor", "exporter"])
+@pytest.mark.parametrize("privacy_source", ["option", "client", "module"])
+def test_otel_privacy_mode_sends_no_content(
+    integration: str,
+    privacy_source: str,
+    provider_metadata: str,
+    kept_provider_metadata: Dict[str, str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    pytest.importorskip("opentelemetry.exporter.otlp.proto.http")
+    import posthog
+    from opentelemetry.exporter.otlp.proto.common.trace_encoder import encode_spans
+
+    monkeypatch.setattr(posthog, "privacy_mode", privacy_source == "module")
+    options: Dict[str, Any] = {
+        "privacy_mode": privacy_source == "option",
+        "client": (
+            Client(FAKE_TEST_API_KEY, privacy_mode=True)
+            if privacy_source == "client"
+            else None
+        ),
+    }
+    [span] = _export_spans(
+        integration,
+        options,
+        lambda provider: _emit_canary_span(provider, provider_metadata),
+    )
+
+    assert CANARY.encode() not in encode_spans([span]).SerializeToString()
+    assert dict(span.attributes or {}) == {
+        **_KEPT_OTEL_ATTRIBUTES,
+        **_REDACTED_MCP_OTEL_TOOL_ATTRIBUTES,
+        **kept_provider_metadata,
+    }
+    [exception_event] = span.events
+    assert exception_event.name == "exception"
+    exception_attributes = dict(exception_event.attributes or {})
+    assert exception_attributes["exception.type"] == "ValueError"
+    assert set(exception_attributes) <= {"exception.type", "exception.escaped"}
+    assert span.status.is_ok is False
+    assert span.status.description is None
+
+
+@pytest.mark.parametrize("integration", ["processor", "exporter"])
+def test_otel_masks_mcp_credentials_without_privacy_mode(
+    integration: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    pytest.importorskip("opentelemetry.exporter.otlp.proto.http")
+    import posthog
+    from opentelemetry.exporter.otlp.proto.common.trace_encoder import encode_spans
+
+    monkeypatch.setattr(posthog, "privacy_mode", False)
+    attributes = {
+        **_KEPT_OTEL_ATTRIBUTES,
+        **_MCP_OTEL_TOOL_ATTRIBUTES,
+        "gen_ai.input.messages": "user prompt",
+    }
+
+    def emit(provider: Any) -> None:
+        with provider.get_tracer("test").start_as_current_span(
+            "gen_ai.chat", attributes=attributes
+        ):
+            pass
+
+    [span] = _export_spans(integration, {"privacy_mode": False}, emit)
+
+    encode_spans([span])
+    assert dict(span.attributes or {}) == {
+        **attributes,
+        **_REDACTED_MCP_OTEL_TOOL_ATTRIBUTES,
+        "llm.tools.1.tool.json_schema": f"not json {CANARY}",
+    }
+
+
+@pytest.mark.parametrize("privacy_mode", [True, False])
+def test_otel_exporter_drops_only_the_span_that_fails_redaction(
+    privacy_mode: bool,
+) -> None:
+    pytest.importorskip("opentelemetry.exporter.otlp.proto.http")
+    from opentelemetry.sdk.trace import TracerProvider
+
+    from posthog.ai.otel import PostHogTraceExporter
+
+    tracer = TracerProvider().get_tracer("test")
+    broken = tracer.start_span(
+        "gen_ai.chat", attributes={"ai.prompt.tools": json.dumps(_MCP_OTEL_TOOL)}
+    )
+    healthy = tracer.start_span(
+        "gen_ai.chat", attributes={"gen_ai.request.model": "gpt-4o"}
+    )
+    broken.end()
+    healthy.end()
+
+    with (
+        patch("posthog.ai.otel.exporter.OTLPSpanExporter") as otlp,
+        # Deeply nested JSON raises RecursionError while parsing on some Python versions.
+        patch("posthog.ai.otel._privacy._redact_mcp_tool", side_effect=RecursionError),
+    ):
+        PostHogTraceExporter(api_key="phc_test", privacy_mode=privacy_mode).export(
+            [broken, healthy]
+        )
+
+    [spans] = otlp.return_value.export.call_args.args
+    assert [dict(span.attributes or {}) for span in spans] == [
+        {"gen_ai.request.model": "gpt-4o"}
+    ]
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index d3a7b1847..feb33578b 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -208,10 +208,12 @@ alias posthog.ai.openai_agents.processor.finalize_ai_content -> posthog.ai.utils
 alias posthog.ai.openai_agents.processor.setup -> posthog.setup
 alias posthog.ai.otel.PostHogSpanProcessor -> posthog.ai.otel.processor.PostHogSpanProcessor
 alias posthog.ai.otel.PostHogTraceExporter -> posthog.ai.otel.exporter.PostHogTraceExporter
+alias posthog.ai.otel.exporter.Client -> posthog.client.Client
 alias posthog.ai.otel.exporter.DEFAULT_HOST -> posthog.ai.otel.spans.DEFAULT_HOST
 alias posthog.ai.otel.exporter.is_ai_span -> posthog.ai.otel.spans.is_ai_span
 alias posthog.ai.otel.exporter.warn_if_posthog_ai_gateway_otel_attributes -> posthog.ai.gateway.warn_if_posthog_ai_gateway_otel_attributes
 alias posthog.ai.otel.is_ai_span -> posthog.ai.otel.spans.is_ai_span
+alias posthog.ai.otel.processor.Client -> posthog.client.Client
 alias posthog.ai.otel.processor.DEFAULT_HOST -> posthog.ai.otel.spans.DEFAULT_HOST
 alias posthog.ai.otel.processor.is_ai_span -> posthog.ai.otel.spans.is_ai_span
 alias posthog.ai.otel.processor.warn_if_posthog_ai_gateway_otel_attributes -> posthog.ai.gateway.warn_if_posthog_ai_gateway_otel_attributes
@@ -1254,8 +1256,8 @@ class posthog.ai.openai.openai_async.WrappedResponses
 class posthog.ai.openai.openai_providers.AsyncAzureOpenAI(posthog_client: Optional[PostHogClient] = None, **kwargs)
 class posthog.ai.openai.openai_providers.AzureOpenAI(posthog_client: Optional[PostHogClient] = None, **kwargs)
 class posthog.ai.openai_agents.processor.PostHogTracingProcessor(client: Optional[Client] = None, distinct_id: Optional[Union[str, Callable[[Trace], Optional[str]]]] = None, privacy_mode: bool = False, groups: Optional[Dict[str, Any]] = None, properties: Optional[Dict[str, Any]] = None)
-class posthog.ai.otel.exporter.PostHogTraceExporter(api_key: str, host: str = DEFAULT_HOST)
-class posthog.ai.otel.processor.PostHogSpanProcessor(api_key: str, host: str = DEFAULT_HOST)
+class posthog.ai.otel.exporter.PostHogTraceExporter(api_key: str, host: str = DEFAULT_HOST, *, privacy_mode: bool = False, client: Optional[Client] = None)
+class posthog.ai.otel.processor.PostHogSpanProcessor(api_key: str, host: str = DEFAULT_HOST, *, privacy_mode: bool = False, client: Optional[Client] = None)
 class posthog.ai.prompts.CachedPrompt(prompt: str, fetched_at: float, name: str, version: int, label: Optional[str] = None, config: Optional[Dict[str, Any]] = None)
 class posthog.ai.prompts.PromptFetchError(message: str, retry_after_seconds: Optional[float] = None)
 class posthog.ai.prompts.PromptResult(source: PromptSource, prompt: str, name: Optional[str] = None, version: Optional[int] = None, label: Optional[str] = None, config: Optional[Dict[str, Any]] = None)

From fb9b66bcc1d679180f5aee9c1fe4397636074c75 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 15:26:03 +0000
Subject: [PATCH 108/245] chore: Release v7.75.11 [skip ci]

---
 .sampo/changesets/ai-privacy-mode-leaks.md | 12 ------------
 openfeature-provider/CHANGELOG.md          |  6 ++++++
 openfeature-provider/pyproject.toml        |  2 +-
 posthog/CHANGELOG.md                       | 13 +++++++++++++
 posthog/version.py                         |  2 +-
 pyproject.toml                             |  2 +-
 uv.lock                                    |  4 ++--
 7 files changed, 24 insertions(+), 17 deletions(-)
 delete mode 100644 .sampo/changesets/ai-privacy-mode-leaks.md

diff --git a/.sampo/changesets/ai-privacy-mode-leaks.md b/.sampo/changesets/ai-privacy-mode-leaks.md
deleted file mode 100644
index 8eb4ececd..000000000
--- a/.sampo/changesets/ai-privacy-mode-leaks.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-pypi/posthog: patch
----
-
-Privacy mode now covers error text and the remaining content paths in the AI integrations.
-
-- `$ai_error` no longer carries the exception message when privacy mode is on. Provider errors and validation errors often quote the prompt or the model output, so the SDK now sends a summary built only from structured fields: the class name, HTTP status, provider error code, `param`, request ID and the class names of chained causes (for example `BadRequestError: 400 invalid_request_error param=messages[3].content request_id=req_123`). This applies to the OpenAI, Anthropic and Gemini wrappers (including Gemini embeddings), LangChain generations, spans and traces, and OpenAI Agents spans.
-- The LangChain callback handler no longer sends an `$exception` event for a failed run when privacy mode is on.
-- `$ai_tools` masks the `headers` and `authorization` of MCP tool definitions (`type: "mcp"`) with `[REDACTED]`, with or without privacy mode. The tools you pass in are not modified.
-- Gemini: a per-call `posthog_privacy_mode=False` no longer turns off privacy mode set on the client, matching the OpenAI and Anthropic wrappers.
-- OpenAI Agents: privacy mode now redacts `$ai_trace_metadata` and the `prompt` and `instructions` in transcription and speech span `model_config`.
-- OpenTelemetry: `PostHogSpanProcessor` and `PostHogTraceExporter` accept `privacy_mode` and `client`, and also honor the client's (or the module-level) `privacy_mode`. When on, exported spans drop prompt, completion, tool argument and tool result attributes, non-exception span events, exception messages and stack traces, and the span status description.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 4ba230b60..5f930ed78 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.125 — 2026-10-23
+
+### Patch changes
+
+- Updated dependencies: posthog@7.75.11
+
 ## 0.1.124 — 2026-10-23
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 32ef79c50..46b689f5e 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.124"
+version = "0.1.125"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 0b165616b..32d74af17 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,18 @@
 # posthog
 
+## 7.75.11 — 2026-10-23
+
+### Patch changes
+
+- [04e6a4c](https://github.com/posthog/posthog-python/commit/04e6a4c1c4f15e4dd0d010dee5fa83244f9b6dd8) Privacy mode now covers error text and the remaining content paths in the AI integrations.
+  
+  - `$ai_error` no longer carries the exception message when privacy mode is on. Provider errors and validation errors often quote the prompt or the model output, so the SDK now sends a summary built only from structured fields: the class name, HTTP status, provider error code, `param`, request ID and the class names of chained causes (for example `BadRequestError: 400 invalid_request_error param=messages[3].content request_id=req_123`). This applies to the OpenAI, Anthropic and Gemini wrappers (including Gemini embeddings), LangChain generations, spans and traces, and OpenAI Agents spans.
+  - The LangChain callback handler no longer sends an `$exception` event for a failed run when privacy mode is on.
+  - `$ai_tools` masks the `headers` and `authorization` of MCP tool definitions (`type: "mcp"`) with `[REDACTED]`, with or without privacy mode. The tools you pass in are not modified.
+  - Gemini: a per-call `posthog_privacy_mode=False` no longer turns off privacy mode set on the client, matching the OpenAI and Anthropic wrappers.
+  - OpenAI Agents: privacy mode now redacts `$ai_trace_metadata` and the `prompt` and `instructions` in transcription and speech span `model_config`.
+  - OpenTelemetry: `PostHogSpanProcessor` and `PostHogTraceExporter` accept `privacy_mode` and `client`, and also honor the client's (or the module-level) `privacy_mode`. When on, exported spans drop prompt, completion, tool argument and tool result attributes, non-exception span events, exception messages and stack traces, and the span status description. — Thanks @carlos-marchal-ph!
+
 ## 7.75.10 — 2026-10-23
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 80d27f167..0d256d5f2 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.10"
+VERSION = "7.75.11"
diff --git a/pyproject.toml b/pyproject.toml
index fd257b27f..013ab862a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.10"
+version = "7.75.11"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index ce6945262..4fa80ae49 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.124"
+version = "0.1.125"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3024,7 +3024,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.10"
+version = "7.75.11"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 16d618b1636e47dfcd3a530231fddf16defa6b81 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 15:26:08 +0000
Subject: [PATCH 109/245] Update generated references

---
 .../posthog-python-references-7.75.11.json    | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.75.11.json

diff --git a/references/posthog-python-references-7.75.11.json b/references/posthog-python-references-7.75.11.json
new file mode 100644
index 000000000..00e8b9d05
--- /dev/null
+++ b/references/posthog-python-references-7.75.11.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.75.11",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 226ca01c2..00e8b9d05 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.10",
+    "version": "7.75.11",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From bc7b40331a4a9bf18456f6e9136147ab7118ca0f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:24:08 -0400
Subject: [PATCH 110/245] chore(deps): bump opentelemetry-api from 1.40.0 to
 1.45.1 (#1117)

Bumps [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python) from 1.40.0 to 1.45.1.
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

---
updated-dependencies:
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 80 +++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 55 insertions(+), 25 deletions(-)

diff --git a/uv.lock b/uv.lock
index 4fa80ae49..82f53bc73 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2700,50 +2700,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -2751,62 +2781,62 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation-celery"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-instrumentation" },
     { name = "opentelemetry-semantic-conventions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8d/43/e79108a804d16b1dc8ff28edd0e94ac393cf6359a5adcd7cdd2ec4be85f4/opentelemetry_instrumentation_celery-0.61b0.tar.gz", hash = "sha256:0e352a567dc89ed8bc083fc635035ce3c5b96bbbd92831ffd676e93b87f8e94f", size = 14780, upload-time = "2026-03-04T14:20:27.776Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d5/66/c2bbfbb7c90850dc52dee5d4968ab45a986093d2b77a631ff17e4107eefc/opentelemetry_instrumentation_celery-0.66b1.tar.gz", hash = "sha256:3b6c5539c8d4a060edbc0eb1f334ef909d0f9a5ecb7af545bdd73644e6e2e814", size = 15947, upload-time = "2026-10-06T17:36:20.175Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a2/ed/c05f3c84b455654eb6c047474ffde61ed92efc24030f64213c98bca9d44b/opentelemetry_instrumentation_celery-0.61b0-py3-none-any.whl", hash = "sha256:01235733ff0cdf571cb03b270645abb14b9c8d830313dc5842097ec90146320b", size = 13856, upload-time = "2026-03-04T14:19:20.98Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/73/b7597b2fede14cafe7122d1028bd6f648d9c1e049a61ab36481a4ed4f0df/opentelemetry_instrumentation_celery-0.66b1-py3-none-any.whl", hash = "sha256:145b5eece41331141edc8f454984238b05b107d7ead928b49e7a1916d5e48e99", size = 13480, upload-time = "2026-10-06T17:35:25.828Z" },
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]

From 125b26654ea317ce72077b7f3eb83d11461cf9b2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:24:19 -0400
Subject: [PATCH 111/245] chore(deps): bump djangorestframework from 3.18.1 to
 3.18.2 (#1118)

Bumps [djangorestframework](https://github.com/encode/django-rest-framework) from 3.18.1 to 3.18.2.
- [Release notes](https://github.com/encode/django-rest-framework/releases)
- [Commits](https://github.com/encode/django-rest-framework/compare/3.18.1...3.18.2)

---
updated-dependencies:
- dependency-name: djangorestframework
  dependency-version: 3.18.2
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index 82f53bc73..665480483 100644
--- a/uv.lock
+++ b/uv.lock
@@ -967,14 +967,14 @@ wheels = [
 
 [[package]]
 name = "djangorestframework"
-version = "3.18.1"
+version = "3.18.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "django" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8a/2e/b3ce9d449b1ed9f9dd74fb7dfbc5f20860d5f40c2b4b10a2c3eabd8ff579/djangorestframework-3.18.1.tar.gz", hash = "sha256:605d79fa2ec2f02905492e5ea13d903c2d842d0b4c915a57f7bf02ab9f3c91dd", size = 915653, upload-time = "2026-09-07T18:04:08.288Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/8b/2f048189610d58b29ae947f46d9c7d19c20ba427568eac906d6a2277d391/djangorestframework-3.18.2.tar.gz", hash = "sha256:8249bad7715eb37274ce5820fc5d9fd786b7579806589565f52a71c02b35f54b", size = 923551, upload-time = "2026-10-06T20:42:15.116Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/83/5ed615e47339d8e65f62eb1a8133f8f046492eb3a25ad40d90acb9a208b3/djangorestframework-3.18.1-py3-none-any.whl", hash = "sha256:f1409d698967aaf82d5d98d76b549c8fba8bd92ebd0d83d24454508f72168dc2", size = 901373, upload-time = "2026-09-07T18:04:06.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/9e/81e5bfbba54f7396233df979befde49e6e13c94c2df21b94555684dddd3e/djangorestframework-3.18.2-py3-none-any.whl", hash = "sha256:a92d6a4e128a2550bd2fe2e02008a9e47fe52c180e130bb438f5ba70ee933a3f", size = 903990, upload-time = "2026-10-06T20:42:13.411Z" },
 ]
 
 [[package]]

From 3f6c80eb4df1ddffd9e5b9d1d8aae8facf9f83b2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 23 Oct 2026 12:24:30 -0400
Subject: [PATCH 112/245] chore(deps): bump the uv group across 31 directories
 with 1 update (#1119)

Bumps the uv group with 1 update in the /examples/example-ai-anthropic directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-autogen directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-aws-bedrock directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-azure-openai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-cerebras directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-cloudflare-ai-gateway directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-cohere directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-crewai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-dedalus directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-deepseek directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-fireworks-ai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-gemini directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-groq directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-helicone directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-hugging-face directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-instructor directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-langchain directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-langgraph directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-llamaindex directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-mirascope directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-mistral directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-ollama directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-openai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-openrouter directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-perplexity directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-portkey directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-semantic-kernel directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-smolagents directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-together-ai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-vercel-ai-gateway directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).
Bumps the uv group with 1 update in the /examples/example-ai-xai directory: [opentelemetry-api](https://github.com/open-telemetry/opentelemetry-python).


Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.34.1 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

Updates `opentelemetry-api` from 1.40.0 to 1.45.1
- [Release notes](https://github.com/open-telemetry/opentelemetry-python/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-python/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-python/compare/v1.40.0...v1.45.1)

---
updated-dependencies:
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: opentelemetry-api
  dependency-version: 1.45.1
  dependency-type: indirect
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-anthropic/uv.lock         |  97 +++++++++--------
 examples/example-ai-autogen/uv.lock           |  97 +++++++++--------
 examples/example-ai-aws-bedrock/uv.lock       | 102 ++++++++++--------
 examples/example-ai-azure-openai/uv.lock      |  97 +++++++++--------
 examples/example-ai-cerebras/uv.lock          |  97 +++++++++--------
 .../example-ai-cloudflare-ai-gateway/uv.lock  |  97 +++++++++--------
 examples/example-ai-cohere/uv.lock            |  97 +++++++++--------
 examples/example-ai-crewai/uv.lock            |  75 +++++++++----
 examples/example-ai-dedalus/uv.lock           |  97 +++++++++--------
 examples/example-ai-deepseek/uv.lock          |  97 +++++++++--------
 examples/example-ai-fireworks-ai/uv.lock      |  97 +++++++++--------
 examples/example-ai-gemini/uv.lock            |  87 ++++++++-------
 examples/example-ai-groq/uv.lock              |  97 +++++++++--------
 examples/example-ai-helicone/uv.lock          |  97 +++++++++--------
 examples/example-ai-hugging-face/uv.lock      |  97 +++++++++--------
 examples/example-ai-instructor/uv.lock        |  97 +++++++++--------
 examples/example-ai-langchain/uv.lock         |  97 +++++++++--------
 examples/example-ai-langgraph/uv.lock         |  97 +++++++++--------
 examples/example-ai-llamaindex/uv.lock        |  97 +++++++++--------
 examples/example-ai-mirascope/uv.lock         |  97 +++++++++--------
 examples/example-ai-mistral/uv.lock           |  97 +++++++++--------
 examples/example-ai-ollama/uv.lock            |  97 +++++++++--------
 examples/example-ai-openai/uv.lock            |  97 +++++++++--------
 examples/example-ai-openrouter/uv.lock        |  97 +++++++++--------
 examples/example-ai-perplexity/uv.lock        |  97 +++++++++--------
 examples/example-ai-portkey/uv.lock           |  97 +++++++++--------
 examples/example-ai-semantic-kernel/uv.lock   |  97 +++++++++--------
 examples/example-ai-smolagents/uv.lock        |  97 +++++++++--------
 examples/example-ai-together-ai/uv.lock       |  97 +++++++++--------
 examples/example-ai-vercel-ai-gateway/uv.lock |  97 +++++++++--------
 examples/example-ai-xai/uv.lock               |  97 +++++++++--------
 31 files changed, 1641 insertions(+), 1339 deletions(-)

diff --git a/examples/example-ai-anthropic/uv.lock b/examples/example-ai-anthropic/uv.lock
index 2162e2894..7c08e365d 100644
--- a/examples/example-ai-anthropic/uv.lock
+++ b/examples/example-ai-anthropic/uv.lock
@@ -281,18 +281,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -465,41 +483,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -526,7 +544,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -879,12 +897,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-autogen/uv.lock b/examples/example-ai-autogen/uv.lock
index 24352e92e..b1cbe8a8b 100644
--- a/examples/example-ai-autogen/uv.lock
+++ b/examples/example-ai-autogen/uv.lock
@@ -323,18 +323,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -462,50 +450,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -513,9 +531,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -534,41 +552,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -676,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1222,12 +1240,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-aws-bedrock/uv.lock b/examples/example-ai-aws-bedrock/uv.lock
index 002c854bd..3ab92317f 100644
--- a/examples/example-ai-aws-bedrock/uv.lock
+++ b/examples/example-ai-aws-bedrock/uv.lock
@@ -210,72 +210,90 @@ wheels = [
 ]
 
 [[package]]
-name = "importlib-metadata"
-version = "8.7.1"
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "zipp" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
 ]
 
 [[package]]
-name = "jmespath"
-version = "1.1.0"
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
 ]
 
 [[package]]
-name = "opentelemetry-api"
-version = "1.40.0"
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
-    { name = "typing-extensions" },
+    { name = "opentelemetry-sdk" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -283,24 +301,25 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation-botocore"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-instrumentation" },
     { name = "opentelemetry-propagator-aws-xray" },
     { name = "opentelemetry-semantic-conventions" },
+    { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/7f/2acb6d4e8cc70726cfbb24885a653ef5fdc3ac2d0a26ca3e6bff58416c2e/opentelemetry_instrumentation_botocore-0.61b0.tar.gz", hash = "sha256:49dee5f48d133b3bfadaa29bcbff28225899dc495ca14a9c1bb60b74fb4cd84d", size = 121236, upload-time = "2026-03-04T14:20:26.426Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f6/f648150c2bf30784b4ff448c15a6b5ad804ac41b91362ebe023ce14b88c3/opentelemetry_instrumentation_botocore-0.66b1.tar.gz", hash = "sha256:c601923e40aa008f4c0466b714c112fe47da07adb72ae6c69e2ac95992bcd66e", size = 129133, upload-time = "2026-10-06T17:36:18.898Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/43/0ed1ac34b52a62b3694c22aee5c7a9c5b6120938d927d79de53ad9edb0cf/opentelemetry_instrumentation_botocore-0.61b0-py3-none-any.whl", hash = "sha256:b019d2f60562265319e64a75c1c9e7bad31c00b2a568def3cc5c57eaf9a06057", size = 38359, upload-time = "2026-03-04T14:19:19.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6b/1f467c7e5725a8df6c2ed59446c5b9632bc480a525396a962ab67a4d7f28/opentelemetry_instrumentation_botocore-0.66b1-py3-none-any.whl", hash = "sha256:6352ceb4f204b13cd5b448f4df10de4a1a82f345fd0a81f8816a60e9ce3fdfc2", size = 36199, upload-time = "2026-10-06T17:35:23.976Z" },
 ]
 
 [[package]]
@@ -317,41 +336,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -365,7 +384,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -597,12 +616,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-azure-openai/uv.lock b/examples/example-ai-azure-openai/uv.lock
index 887d67488..a5ef6855e 100644
--- a/examples/example-ai-azure-openai/uv.lock
+++ b/examples/example-ai-azure-openai/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-cerebras/uv.lock b/examples/example-ai-cerebras/uv.lock
index ef3100dc7..c93a3adde 100644
--- a/examples/example-ai-cerebras/uv.lock
+++ b/examples/example-ai-cerebras/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-cloudflare-ai-gateway/uv.lock b/examples/example-ai-cloudflare-ai-gateway/uv.lock
index fad13fdb0..b57760592 100644
--- a/examples/example-ai-cloudflare-ai-gateway/uv.lock
+++ b/examples/example-ai-cloudflare-ai-gateway/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-cohere/uv.lock b/examples/example-ai-cohere/uv.lock
index 0e7c2a2a9..19e58c7b4 100644
--- a/examples/example-ai-cohere/uv.lock
+++ b/examples/example-ai-cohere/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index 547ca5a1b..1998b05a2 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -2325,102 +2325,133 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4d/5e/94a8cb759e4e409022229418294e098ca7feca00eb3c467bb20cbd329bda/opentelemetry_api-1.34.1.tar.gz", hash = "sha256:64f0bd06d42824843731d05beea88d4d4b6ae59f9fe347ff7dfa2cc14233bbb3", size = 64987, upload-time = "2025-06-10T08:55:19.818Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a5/3a/2ba85557e8dc024c0842ad22c570418dc02c36cbd1ab4b832a93edf071b8/opentelemetry_api-1.34.1-py3-none-any.whl", hash = "sha256:b7df4cb0830d5a6c29ad0c0691dbae874d8daefa934b8b1d642de48323d32a8c", size = 65767, upload-time = "2025-06-10T08:54:56.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/86/f0/ff235936ee40db93360233b62da932d4fd9e8d103cd090c6bcb9afaf5f01/opentelemetry_exporter_otlp_proto_common-1.34.1.tar.gz", hash = "sha256:b59a20a927facd5eac06edaf87a07e49f9e4a13db487b7d8a52b37cb87710f8b", size = 20817, upload-time = "2025-06-10T08:55:22.55Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/72/e8/8b292a11cc8d8d87ec0c4089ae21b6a58af49ca2e51fa916435bc922fdc7/opentelemetry_exporter_otlp_proto_common-1.34.1-py3-none-any.whl", hash = "sha256:8e2019284bf24d3deebbb6c59c71e6eef3307cd88eff8c633e061abba33f7e87", size = 18834, upload-time = "2025-06-10T08:55:00.806Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-grpc"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "grpcio" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/41/f7/bb63837a3edb9ca857aaf5760796874e7cecddc88a2571b0992865a48fb6/opentelemetry_exporter_otlp_proto_grpc-1.34.1.tar.gz", hash = "sha256:7c841b90caa3aafcfc4fee58487a6c71743c34c6dc1787089d8b0578bbd794dd", size = 22566, upload-time = "2025-06-10T08:55:23.214Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/00/a82af0be959dc58495740b169c6669a86e0811f6cd353a01eda34d255db3/opentelemetry_exporter_otlp_proto_grpc-1.45.1.tar.gz", hash = "sha256:3b3dcfbfdcb4e35149fcf309972282054b45228f5c10547d0095d6578510a9a0", size = 25997, upload-time = "2026-10-06T17:33:05.114Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/42/0a4dd47e7ef54edf670c81fc06a83d68ea42727b82126a1df9dd0477695d/opentelemetry_exporter_otlp_proto_grpc-1.34.1-py3-none-any.whl", hash = "sha256:04bb8b732b02295be79f8a86a4ad28fae3d4ddb07307a98c7aa6f331de18cca6", size = 18615, upload-time = "2025-06-10T08:55:02.214Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/46/2d1da202f1e17c81aae7efcf702898d524b46709e4d3e2bf1f7f8ca8fbc6/opentelemetry_exporter_otlp_proto_grpc-1.45.1-py3-none-any.whl", hash = "sha256:e42ecb789d2fc5d8145e3dadc3e2991c9f18cd166d7c7514e234702540274b76", size = 19492, upload-time = "2026-10-06T17:32:42.838Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/19/8f/954bc725961cbe425a749d55c0ba1df46832a5999eae764d1a7349ac1c29/opentelemetry_exporter_otlp_proto_http-1.34.1.tar.gz", hash = "sha256:aaac36fdce46a8191e604dcf632e1f9380c7d5b356b27b3e0edb5610d9be28ad", size = 15351, upload-time = "2025-06-10T08:55:24.657Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/54/b05251c04e30c1ac70cf4a7c5653c085dfcf2c8b98af71661d6a252adc39/opentelemetry_exporter_otlp_proto_http-1.34.1-py3-none-any.whl", hash = "sha256:5251f00ca85872ce50d871f6d3cc89fe203b94c3c14c964bbdc3883366c705d8", size = 17744, upload-time = "2025-06-10T08:55:03.802Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/b3/c3158dd012463bb7c0eb7304a85a6f63baeeb5b4c93a53845cf89f848c7e/opentelemetry_proto-1.34.1.tar.gz", hash = "sha256:16286214e405c211fc774187f3e4bbb1351290b8dfb88e8948af209ce85b719e", size = 34344, upload-time = "2025-06-10T08:55:32.25Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/28/ab/4591bfa54e946350ce8b3f28e5c658fe9785e7cd11e9c11b1671a867822b/opentelemetry_proto-1.34.1-py3-none-any.whl", hash = "sha256:eb4bb5ac27f2562df2d6857fc557b3a481b5e298bc04f94cc68041f00cebcbd2", size = 55692, upload-time = "2025-06-10T08:55:14.904Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.34.1"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6f/41/fe20f9036433da8e0fcef568984da4c1d1c771fa072ecd1a4d98779dccdd/opentelemetry_sdk-1.34.1.tar.gz", hash = "sha256:8091db0d763fcd6098d4781bbc80ff0971f94e260739aa6afe6fd379cdf3aa4d", size = 159441, upload-time = "2025-06-10T08:55:33.028Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/1b/def4fe6aa73f483cabf4c748f4c25070d5f7604dcc8b52e962983491b29e/opentelemetry_sdk-1.34.1-py3-none-any.whl", hash = "sha256:308effad4059562f1d92163c61c8141df649da24ce361827812c40abb2a1e96e", size = 118477, upload-time = "2025-06-10T08:55:16.02Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.55b1"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5d/f0/f33458486da911f47c4aa6db9bda308bb80f3236c111bf848bd870c16b16/opentelemetry_semantic_conventions-0.55b1.tar.gz", hash = "sha256:ef95b1f009159c28d7a7849f5cbc71c4c34c845bb514d66adfdf1b3fff3598b3", size = 119829, upload-time = "2025-06-10T08:55:33.881Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1a/89/267b0af1b1d0ba828f0e60642b6a5116ac1fd917cde7fc02821627029bd1/opentelemetry_semantic_conventions-0.55b1-py3-none-any.whl", hash = "sha256:5da81dfdf7d52e3d37f8fe88d5e771e191de924cfff5f550ab0b8f7b2409baed", size = 196223, upload-time = "2025-06-10T08:55:17.638Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-dedalus/uv.lock b/examples/example-ai-dedalus/uv.lock
index 87710ad73..2dfb0a292 100644
--- a/examples/example-ai-dedalus/uv.lock
+++ b/examples/example-ai-dedalus/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-deepseek/uv.lock b/examples/example-ai-deepseek/uv.lock
index bd66d5ec4..7dd79a938 100644
--- a/examples/example-ai-deepseek/uv.lock
+++ b/examples/example-ai-deepseek/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-fireworks-ai/uv.lock b/examples/example-ai-fireworks-ai/uv.lock
index 978ae3f32..2a573ab26 100644
--- a/examples/example-ai-fireworks-ai/uv.lock
+++ b/examples/example-ai-fireworks-ai/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-gemini/uv.lock b/examples/example-ai-gemini/uv.lock
index f512aff3c..0402b9905 100644
--- a/examples/example-ai-gemini/uv.lock
+++ b/examples/example-ai-gemini/uv.lock
@@ -432,63 +432,81 @@ wheels = [
 ]
 
 [[package]]
-name = "importlib-metadata"
-version = "8.7.1"
+name = "opentelemetry-api"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "zipp" },
+    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
 ]
 
 [[package]]
-name = "opentelemetry-api"
-version = "1.40.0"
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
-    { name = "typing-extensions" },
+    { name = "opentelemetry-api" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -496,9 +514,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -518,41 +536,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -579,7 +597,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1039,12 +1057,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-groq/uv.lock b/examples/example-ai-groq/uv.lock
index 3a4b5205b..53278b351 100644
--- a/examples/example-ai-groq/uv.lock
+++ b/examples/example-ai-groq/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-helicone/uv.lock b/examples/example-ai-helicone/uv.lock
index 28b21350c..803a8a6d8 100644
--- a/examples/example-ai-helicone/uv.lock
+++ b/examples/example-ai-helicone/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-hugging-face/uv.lock b/examples/example-ai-hugging-face/uv.lock
index c911563ad..b853347c5 100644
--- a/examples/example-ai-hugging-face/uv.lock
+++ b/examples/example-ai-hugging-face/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-instructor/uv.lock b/examples/example-ai-instructor/uv.lock
index 6a6d1eace..bde3f9560 100644
--- a/examples/example-ai-instructor/uv.lock
+++ b/examples/example-ai-instructor/uv.lock
@@ -645,18 +645,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "instructor"
 version = "1.14.5"
@@ -1097,50 +1085,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -1148,9 +1166,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -1169,41 +1187,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -1217,7 +1235,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1901,12 +1919,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
     { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-langchain/uv.lock b/examples/example-ai-langchain/uv.lock
index d72389757..00c05f8ec 100644
--- a/examples/example-ai-langchain/uv.lock
+++ b/examples/example-ai-langchain/uv.lock
@@ -264,18 +264,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -559,50 +547,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -610,9 +628,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -632,41 +650,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -830,7 +848,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1669,15 +1687,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
 ]
 
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
-
 [[package]]
 name = "zstandard"
 version = "0.25.0"
diff --git a/examples/example-ai-langgraph/uv.lock b/examples/example-ai-langgraph/uv.lock
index 0fc330260..436b5d46a 100644
--- a/examples/example-ai-langgraph/uv.lock
+++ b/examples/example-ai-langgraph/uv.lock
@@ -268,18 +268,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -545,50 +533,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -596,9 +614,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -618,41 +636,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -816,7 +834,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1712,15 +1730,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
 ]
 
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
-
 [[package]]
 name = "zstandard"
 version = "0.25.0"
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index f74f56fb4..af7f08f09 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -803,18 +803,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "inflection"
 version = "0.5.1"
@@ -1570,50 +1558,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -1621,9 +1639,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -1644,41 +1662,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -1808,7 +1826,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2788,12 +2806,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
     { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-mirascope/uv.lock b/examples/example-ai-mirascope/uv.lock
index 236ddaeb6..57bf711c8 100644
--- a/examples/example-ai-mirascope/uv.lock
+++ b/examples/example-ai-mirascope/uv.lock
@@ -273,18 +273,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -419,50 +407,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -470,9 +488,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -491,41 +509,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -539,7 +557,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -904,12 +922,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-mistral/uv.lock b/examples/example-ai-mistral/uv.lock
index 3ae20625e..af7616869 100644
--- a/examples/example-ai-mistral/uv.lock
+++ b/examples/example-ai-mistral/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-ollama/uv.lock b/examples/example-ai-ollama/uv.lock
index 88ab43899..e55d5b5d2 100644
--- a/examples/example-ai-ollama/uv.lock
+++ b/examples/example-ai-ollama/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-openai/uv.lock b/examples/example-ai-openai/uv.lock
index abd252aa1..b7cb99338 100644
--- a/examples/example-ai-openai/uv.lock
+++ b/examples/example-ai-openai/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-openrouter/uv.lock b/examples/example-ai-openrouter/uv.lock
index 2468a06ab..7d07fff22 100644
--- a/examples/example-ai-openrouter/uv.lock
+++ b/examples/example-ai-openrouter/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-perplexity/uv.lock b/examples/example-ai-perplexity/uv.lock
index 45e91258d..5863f63b5 100644
--- a/examples/example-ai-perplexity/uv.lock
+++ b/examples/example-ai-perplexity/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-portkey/uv.lock b/examples/example-ai-portkey/uv.lock
index 77d4a6595..e609b0661 100644
--- a/examples/example-ai-portkey/uv.lock
+++ b/examples/example-ai-portkey/uv.lock
@@ -273,18 +273,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -403,50 +391,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -454,9 +472,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -475,41 +493,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -544,7 +562,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -921,12 +939,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-semantic-kernel/uv.lock b/examples/example-ai-semantic-kernel/uv.lock
index 293cbf9d4..b19ee0951 100644
--- a/examples/example-ai-semantic-kernel/uv.lock
+++ b/examples/example-ai-semantic-kernel/uv.lock
@@ -1091,18 +1091,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9c/1f/19ebc343cc71a7ffa78f17018535adc5cbdd87afb31d7c34874680148b32/ifaddr-0.2.0-py3-none-any.whl", hash = "sha256:085e0305cfe6f16ab12d72e2024030f5d52674afad6911bb1eee207177b8a748", size = 12314, upload-time = "2022-06-15T21:40:25.756Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "isodate"
 version = "0.7.2"
@@ -1876,50 +1864,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -1927,9 +1945,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -1948,41 +1966,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -2014,7 +2032,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -3320,12 +3338,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" },
     { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-smolagents/uv.lock b/examples/example-ai-smolagents/uv.lock
index 7cbaabb7a..a35eb7501 100644
--- a/examples/example-ai-smolagents/uv.lock
+++ b/examples/example-ai-smolagents/uv.lock
@@ -333,18 +333,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jinja2"
 version = "3.1.6"
@@ -581,50 +569,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -632,9 +650,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -653,41 +671,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -795,7 +813,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1272,12 +1290,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-together-ai/uv.lock b/examples/example-ai-together-ai/uv.lock
index eb2c37bd1..ab3afb7e5 100644
--- a/examples/example-ai-together-ai/uv.lock
+++ b/examples/example-ai-together-ai/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-vercel-ai-gateway/uv.lock b/examples/example-ai-vercel-ai-gateway/uv.lock
index ef3264472..554ae8151 100644
--- a/examples/example-ai-vercel-ai-gateway/uv.lock
+++ b/examples/example-ai-vercel-ai-gateway/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]
diff --git a/examples/example-ai-xai/uv.lock b/examples/example-ai-xai/uv.lock
index 24f779a26..25459e607 100644
--- a/examples/example-ai-xai/uv.lock
+++ b/examples/example-ai-xai/uv.lock
@@ -262,18 +262,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
-]
-
 [[package]]
 name = "jiter"
 version = "0.13.0"
@@ -392,50 +380,80 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-api"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "importlib-metadata" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/02/6e0ae9cc61bd3169d401077b507b3ebc344745171e1051ab430be012dcd9/opentelemetry_api-1.45.1.tar.gz", hash = "sha256:aa38ed19bcc084ba42782a73255b3582283eced7ad6dddbd6695189e69adfb75", size = 72804, upload-time = "2026-10-06T17:32:58.133Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-http-transport"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/62/0c/e3ebdb4b507f66afcc905e6885a4946969bd75b45988492643356fbbdc63/opentelemetry_exporter_http_transport-0.66b1.tar.gz", hash = "sha256:443080203bf52586ce0b2ad901e8951c61833eab1aa539ae6f1f16fe9e8e7952", size = 11693, upload-time = "2026-10-06T17:32:59.65Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/69/6af86ff66492b481c6a4c05dcfd68beb47ed8ba046440a26a2aac76b95c7/opentelemetry_exporter_http_transport-0.66b1-py3-none-any.whl", hash = "sha256:2f95404bdee7f9d2d529c7de56c7bd86d014d774d8fbf137810e0167f8a492bf", size = 12155, upload-time = "2026-10-06T17:32:35.454Z" },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-common"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/19/41de712173f43057e4532d42ece7d0c6d4210d353e5752433cb14987643f/opentelemetry_exporter_otlp_common-0.66b1.tar.gz", hash = "sha256:6b1403487a2185ac1feb45fd5546fdf8630ce71c36bcefaadf51e2130e9e23f9", size = 14325, upload-time = "2026-10-06T17:33:01.725Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/39/8c23d67665c762aa51840fa06f86e902e8f6f1693bc8d7e3d98cd6e2f753/opentelemetry_exporter_otlp_common-0.66b1-py3-none-any.whl", hash = "sha256:00ff8592c3a7cb729ff3fdc7ffa12372c243bdf2163e80c180994d0c7bd83ee9", size = 12385, upload-time = "2026-10-06T17:32:38.177Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-common"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-proto" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/8e/65e85e5137991a3c493b11682151d198638a5bc1dd4b4c5f67e013c57d7c/opentelemetry_exporter_otlp_proto_common-1.45.1.tar.gz", hash = "sha256:2e4adcc3a67bcf57804fc49514f0ef64974ca7590aa3491da389852b4a0628f6", size = 18873, upload-time = "2026-10-06T17:33:04.471Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+    { url = "https://files.pythonhosted.org/packages/84/aa/92f225d353904e7f70b8b3e3c1b02db0cf56f744c2e83c581dc372e78873/opentelemetry_exporter_otlp_proto_common-1.45.1-py3-none-any.whl", hash = "sha256:2f446183ae7047b036226f1d846c41a834b0e8755ad13b51a51dd38952eb466c", size = 15393, upload-time = "2026-10-06T17:32:41.911Z" },
 ]
 
 [[package]]
 name = "opentelemetry-exporter-otlp-proto-http"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "googleapis-common-protos" },
     { name = "opentelemetry-api" },
+    { name = "opentelemetry-exporter-http-transport", extra = ["requests"] },
+    { name = "opentelemetry-exporter-otlp-common" },
     { name = "opentelemetry-exporter-otlp-proto-common" },
     { name = "opentelemetry-proto" },
     { name = "opentelemetry-sdk" },
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/17/26487707ea4caa97b17e6e4b5fa72133a53512ffa2f5cf7a49ef284b29cb/opentelemetry_exporter_otlp_proto_http-1.45.1.tar.gz", hash = "sha256:45c218405ce3fd879596924b1874bf9a8f6880206d61065c5a912c8e5c297fb7", size = 28839, upload-time = "2026-10-06T17:33:05.713Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
 [[package]]
 name = "opentelemetry-instrumentation"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
@@ -443,9 +461,9 @@ dependencies = [
     { name = "packaging" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/da/37/6bf8e66bfcee5d3c6515b79cb2ee9ad05fe573c20f7ceb288d0e7eeec28c/opentelemetry_instrumentation-0.61b0.tar.gz", hash = "sha256:cb21b48db738c9de196eba6b805b4ff9de3b7f187e4bbf9a466fa170514f1fc7", size = 32606, upload-time = "2026-03-04T14:20:16.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/03/89e47ff8d52a4f83b343e6eb9ef1698ff45357216e5b6b2b21e0da5c5c7d/opentelemetry_instrumentation-0.66b1.tar.gz", hash = "sha256:e79a510f7d87c72d95e964ddb42193a0d9a75668c027d980eab032ea1322a5ce", size = 43308, upload-time = "2026-10-06T17:36:10.703Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/3e/f6f10f178b6316de67f0dfdbbb699a24fbe8917cf1743c1595fb9dcdd461/opentelemetry_instrumentation-0.61b0-py3-none-any.whl", hash = "sha256:92a93a280e69788e8f88391247cc530fd81f16f2b011979d4d6398f805cfbc63", size = 33448, upload-time = "2026-03-04T14:19:02.447Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
 [[package]]
@@ -464,41 +482,41 @@ wheels = [
 
 [[package]]
 name = "opentelemetry-proto"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/7f/15f014fb195da6c2dbb6c71399b8e76824878718e94de6454038488eed28/opentelemetry_proto-1.45.1.tar.gz", hash = "sha256:79e0fb95e4616691a469439238aa9224d75779b3e108e895d1aa125ab29ca77c", size = 46488, upload-time = "2026-10-06T17:33:11.49Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/9a/42ec8180a769516ae757e893b69736826efceac7332553915b4528a91c6d/opentelemetry_proto-1.45.1-py3-none-any.whl", hash = "sha256:f38e2a8413053c180cd3d2637fbb279673ec2f6a6e09c995aafa2f452c52b46e", size = 72488, upload-time = "2026-10-06T17:32:53.057Z" },
 ]
 
 [[package]]
 name = "opentelemetry-sdk"
-version = "1.40.0"
+version = "1.45.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "opentelemetry-semantic-conventions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/79/7392e21a1c8f0c61d90b223e31c7e48cb9d452e91a6b820ad24cca5f23c4/opentelemetry_sdk-1.45.1.tar.gz", hash = "sha256:63d24a6ca645019a631e6a51999c73e93adcac1196ca640b8ae78a7cc4762bf3", size = 218324, upload-time = "2026-10-06T17:33:13.26Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3c/87c42b4bd6dd297536f04cd9383d212ac557ecd49f2cbdcd46da1c9ef5c8/opentelemetry_sdk-1.45.1-py3-none-any.whl", hash = "sha256:c604c11dc429810812348989115fa44bd558772a3d7442afc43d024f2c250ca4", size = 140063, upload-time = "2026-10-06T17:32:55.04Z" },
 ]
 
 [[package]]
 name = "opentelemetry-semantic-conventions"
-version = "0.61b0"
+version = "0.66b1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "opentelemetry-api" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/e4/dbbfb2a010c4db2224a5114638acede6fe563d33cc20fb1752cebcbe6298/opentelemetry_semantic_conventions-0.66b1.tar.gz", hash = "sha256:497ca63bf383723411e8eaf60c8779e9877633c936bb641080adab59d0eb6ec8", size = 150250, upload-time = "2026-10-06T17:33:14.073Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
 [[package]]
@@ -512,7 +530,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.75.11"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -877,12 +895,3 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" },
     { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" },
 ]
-
-[[package]]
-name = "zipp"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
-]

From 284340d6ba6df08f68c27eac750b13f3ec89ab19 Mon Sep 17 00:00:00 2001
From: Radu Raicea <radu@raicea.com>
Date: Tue, 27 Oct 2026 09:01:42 -0400
Subject: [PATCH 113/245] feat(llma): support per-item offline evaluation
 models (#1130)

---
 .sampo/changesets/jovial-shaman-kullervo.md   |   5 +
 .../example-offline-evaluations/README.md     |   5 +
 posthog/ai/evaluations/_types.py              |   8 +
 posthog/test/ai/test_evaluations.py           | 180 +++++++++++++++++-
 posthog/test/ai/test_evaluations_datasets.py  |  51 +++++
 posthog/test/ai/test_evaluations_transport.py |  91 +++++++++
 references/public_api_snapshot.txt            |   4 +-
 7 files changed, 341 insertions(+), 3 deletions(-)
 create mode 100644 .sampo/changesets/jovial-shaman-kullervo.md

diff --git a/.sampo/changesets/jovial-shaman-kullervo.md b/.sampo/changesets/jovial-shaman-kullervo.md
new file mode 100644
index 000000000..1138e5cc2
--- /dev/null
+++ b/.sampo/changesets/jovial-shaman-kullervo.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add optional per-item model_version to offline evaluations and dataset conversion, preserving model attribution across serialization, retries, and recovery.
diff --git a/examples/example-offline-evaluations/README.md b/examples/example-offline-evaluations/README.md
index 7da7dd1c8..00dfec78e 100644
--- a/examples/example-offline-evaluations/README.md
+++ b/examples/example-offline-evaluations/README.md
@@ -65,6 +65,7 @@ with OfflineEvaluations(
         output="Paris",
         expected_output="Paris",
         case_key="capital-france",
+        model_version="model-b",
     )
     receipt = experiment.upload_result(
         item=item,
@@ -77,6 +78,8 @@ with OfflineEvaluations(
 
 Use one `EvaluationItem` for the application's execution and reuse it across scorer results. `upload_results([EvaluationResult(...), ...])` uploads a finite sequence, eagerly and sequentially. It splits at 1,000 items/results or 5 MiB of UTF-8 JSON per request, whichever comes first. Item payloads are limited to 1 MiB; result payloads to 256 KiB. Payload JSON supports at most 32 nested containers. The SDK raises for invalid values and oversized payloads without truncating them. Memory use scales with the sequence you supply, so submit caller-sized batches for large datasets.
 
+Set `model_version` on each item to compare executions from different models in one experiment. It identifies the application's model and overrides the default supplied to `create_experiment(model_version=...)`. Omit it or pass `None` to inherit that default on the server; without either value, the model remains unknown. Explicit model identifiers must be nonempty strings of at most 255 characters and are preserved without trimming. The declared model is immutable item content: changing, adding, or removing it after acceptance causes a `content_conflict`, even if the effective model is unchanged. Create a new item for a different model execution, and preserve the original declaration for retries.
+
 `status="ok"` means the evaluator ran successfully. Its boolean, number, or category-list `value` is uploaded with its original polarity. Numeric scores use finite double-precision (binary64) values; integer inputs are rejected if conversion would change their value. Use `error`, `skipped`, or `not_applicable` without a value for other outcomes. `error_code` and a non-null `error_message` are valid only with `status="error"`.
 
 Omitted payload fields, explicit `None`, and empty payloads are distinct:
@@ -154,6 +157,8 @@ This example uses string inputs. Replace `capital_answer` and the equality check
 
 `from_dataset_item` copies input, expected output, metadata, and immutable item provenance. It never uses `source_output` as a new execution's output or expected answer, and never uses the original source trace as the new application's trace. Pass `application_trace_id` explicitly for the new execution. Omit `output` if execution failed before producing one, then upload an error outcome. Omitted output differs from `output=None`.
 
+Pass `EvaluationItem.from_dataset_item(case, output=output, model_version="model-b")` to attribute a dataset execution to a model. Calling it again with another model creates a new execution UUID while preserving the same case key and dataset-item version. Omitting the model or passing `None` leaves experiment fallback to the server; dataset metadata and source traces never supply the execution model.
+
 ### Snapshot and pagination behavior
 
 - `snapshot(dataset_id, revision=12)` selects a historical **number**. The returned `revision_id` is the **UUID** to pass to `create_experiment`. The backend derives the remaining hosted-dataset identifiers from that UUID.
diff --git a/posthog/ai/evaluations/_types.py b/posthog/ai/evaluations/_types.py
index 7992ac1c9..595f06920 100644
--- a/posthog/ai/evaluations/_types.py
+++ b/posthog/ai/evaluations/_types.py
@@ -83,6 +83,8 @@ class EvaluationItem:
     Payload values are copied as JSON. Omitted fields differ from explicit None.
     Use ``payload={}`` for an explicitly empty payload. Save ``to_dict()`` to
     restore exactly the same declaration after restarting the process.
+    ``model_version`` identifies this execution's model and overrides the
+    experiment default. Omit it or pass None to inherit the default on the server.
     """
 
     id: str
@@ -102,6 +104,7 @@ def __init__(
         dataset_item_version_identifier: str | None = None,
         dataset_item_version_id: str | UUID | None = None,
         application_trace_id: str | None = None,
+        model_version: str | None = None,
         payload: dict[str, JSONValue] | _Unset = _UNSET,
     ) -> None:
         identity = _uuid(uuid4() if id is None else id)
@@ -112,6 +115,7 @@ def __init__(
             "dataset_item_identifier": dataset_item_identifier,
             "dataset_item_version_identifier": dataset_item_version_identifier,
             "application_trace_id": application_trace_id,
+            "model_version": model_version,
         }.items():
             if value is not None:
                 data[key] = _identifier(value, key)
@@ -146,6 +150,7 @@ def from_dataset_item(
         case_key: str | None = None,
         trial: str | None = None,
         application_trace_id: str | None = None,
+        model_version: str | None = None,
     ) -> EvaluationItem:
         """Declare one execution of a dataset case, preserving its exact version.
 
@@ -156,6 +161,8 @@ def from_dataset_item(
         ``case_key`` defaults to the caller-owned client item ID, or stable item
         UUID. Omit output for an execution that failed before producing one.
         Use the owning snapshot's revision_id when creating the experiment.
+        Supply ``model_version`` for this execution's model; omitted or None
+        inherits the experiment default, never dataset metadata or source traces.
         """
         if not isinstance(item, DatasetItem):
             raise TypeError("Expected a DatasetItem.")
@@ -173,6 +180,7 @@ def from_dataset_item(
             dataset_item_version_identifier=item.version_id,
             dataset_item_version_id=item.version_id,
             application_trace_id=application_trace_id,
+            model_version=model_version,
         )
 
     @classmethod
diff --git a/posthog/test/ai/test_evaluations.py b/posthog/test/ai/test_evaluations.py
index b2e76d0eb..99bcd962c 100644
--- a/posthog/test/ai/test_evaluations.py
+++ b/posthog/test/ai/test_evaluations.py
@@ -276,7 +276,9 @@ def test_resume_is_local_and_supports_references_without_scorer_discovery(client
 
 def test_same_item_is_declared_once_for_multiple_scorers(client):
     evaluations, transport = client
-    item = EvaluationItem(input={"question": "Paris?"}, output="France")
+    item = EvaluationItem(
+        input={"question": "Paris?"}, output="France", model_version="model-b"
+    )
     results = [
         result(item),
         EvaluationResult(item=item, scorer_version_id=OTHER_VERSION_ID, value=True),
@@ -286,11 +288,136 @@ def test_same_item_is_declared_once_for_multiple_scorers(client):
     )
     body = json.loads(transport.request.call_args.kwargs["body"])
     assert body["items"] == [item.to_dict()]
+    assert body["items"][0]["model_version"] == "model-b"
+    assert all("model_version" not in row for row in body["results"])
     assert len(receipt.chunks) == 1
     assert len(receipt.chunks[0].results) == 2
     assert len(receipt.chunks[0].items) == 1
 
 
+@pytest.mark.parametrize("experiment_options", [{}, {"model_version": "model-a"}, None])
+def test_item_models_are_declared_without_resolving_experiment_defaults(
+    client, experiment_options
+):
+    evaluations, transport = client
+    if experiment_options is None:
+        experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+        transport.request.assert_not_called()
+    else:
+        experiment = invoke(
+            evaluations.create_experiment, name="Models", **experiment_options
+        )
+        creation = json.loads(transport.request.call_args.kwargs["body"])
+        assert creation.get("model_version") == experiment_options.get("model_version")
+        transport.request.reset_mock()
+    items = [
+        EvaluationItem(model_version=model)
+        for model in ["model-b", "model-c", "x" * 255, " model with spaces ", None]
+    ] + [EvaluationItem()]
+    invoke(experiment.upload_results, [result(item) for item in items])
+    transport.request.assert_called_once()
+    assert transport.request.call_args.args == (
+        "POST",
+        BASE + experiment.id + "/upload/",
+    )
+    body = json.loads(transport.request.call_args.kwargs["body"])
+    assert body["items"] == [item.to_dict() for item in items]
+    assert [item.get("model_version") for item in body["items"]] == [
+        "model-b",
+        "model-c",
+        "x" * 255,
+        " model with spaces ",
+        None,
+        None,
+    ]
+    assert all("model_version" not in row for row in body["results"])
+    assert all("payload" not in item for item in body["items"])
+    if experiment_options is not None:
+        assert experiment.submission == creation
+
+
+@pytest.mark.parametrize("model", ["", 1, True, [], {}, "x" * 256, "with\x00null"])
+def test_invalid_item_models_are_rejected_before_io(client, model):
+    _, transport = client
+    with pytest.raises(ValueError, match="model_version"):
+        EvaluationItem(model_version=model)
+    with pytest.raises(ValueError, match="model_version"):
+        EvaluationItem.from_dict({"id": str(uuid4()), "model_version": model})
+    transport.request.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "original_model,changed_model",
+    [("model-b", "model-c"), ("model-b", None), (None, "model-a")],
+)
+def test_conflicting_item_models_are_rejected_before_any_bulk_chunk(
+    client, monkeypatch, original_model, changed_model
+):
+    evaluations, transport = client
+    monkeypatch.setattr(_client, "_MAX_RESULTS", 1)
+    item = EvaluationItem(model_version=original_model)
+    changed = EvaluationItem(id=item.id, model_version=changed_model)
+    results = [
+        result(item),
+        EvaluationResult(item=changed, scorer_version_id=OTHER_VERSION_ID, value=True),
+    ]
+    with pytest.raises(ValueError, match="Conflicting"):
+        invoke(evaluations.resume_experiment(EXPERIMENT_ID).upload_results, results)
+    transport.request.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "model_options", [{}, {"model_version": None}, {"model_version": "model-b"}]
+)
+def test_saved_item_models_replay_and_allow_another_scorer_by_uuid(
+    client, model_options
+):
+    evaluations, transport = client
+    experiment = invoke(
+        evaluations.create_experiment, name="Models", model_version="model-a"
+    )
+    item = EvaluationItem(**model_options)
+    original = result(item)
+    first = invoke(experiment.upload_results, [original]).chunks[0]
+    original_body = transport.request.call_args.kwargs["body"]
+    saved = item.to_dict()
+    saved.update(model_options)
+    restored_item = EvaluationItem.from_dict(saved)
+    restored = EvaluationResult.from_dict(original.to_dict(), item=restored_item)
+    second_scorer = EvaluationResult(
+        item=item, scorer_version_id=OTHER_VERSION_ID, value=True
+    )
+    restored_second = EvaluationResult.from_dict(
+        second_scorer.to_dict(), item=restored_item
+    )
+    saved["model_version"] = "changed"
+    assert restored_item.to_dict() == item.to_dict()
+    assert restored.item is restored_second.item is restored_item
+    assert restored.item_id == restored_second.item_id == item.id
+    transport.request.side_effect = lambda method, path, *, body: upload_response(
+        body, created=False
+    )
+    replayed = invoke(experiment.upload_results, [restored]).chunks[0]
+    assert transport.request.call_args.kwargs["body"] == original_body
+    for accepted, replay in zip(
+        first.items + first.results, replayed.items + replayed.results
+    ):
+        assert replay.id == accepted.id
+        assert replay.accepted_at == accepted.accepted_at
+        assert replay.created is False
+    transport.request.reset_mock()
+    invoke(
+        experiment.upload_result,
+        item=item.id,
+        scorer_version_id=OTHER_VERSION_ID,
+        value=True,
+    )
+    transport.request.assert_called_once()
+    body = json.loads(transport.request.call_args.kwargs["body"])
+    assert body["items"] == []
+    assert "model_version" not in body["results"][0]
+
+
 def test_real_result_count_boundary_splits_without_dropping_declarations(client):
     evaluations, transport = client
     results = [result() for _ in range(1001)]
@@ -321,6 +448,57 @@ def test_utf8_byte_boundary_splits_below_request_limit(client):
     )
 
 
+def test_item_models_count_towards_the_encoded_request_limit(client, monkeypatch):
+    evaluations, transport = client
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    items = [EvaluationItem(), EvaluationItem()]
+    invoke(experiment.upload_results, [result(item) for item in items])
+    limit = len(transport.request.call_args.kwargs["body"])
+    monkeypatch.setattr(_client, "_MAX_REQUEST_BYTES", limit)
+    transport.request.reset_mock()
+    modeled = [EvaluationItem(id=item.id, model_version="🙂" * 20) for item in items]
+    receipt = invoke(experiment.upload_results, [result(item) for item in modeled])
+    assert len(receipt.chunks) == 2
+    for call, item in zip(transport.request.call_args_list, modeled):
+        assert len(call.kwargs["body"]) <= limit
+        assert json.loads(call.kwargs["body"])["items"] == [item.to_dict()]
+
+
+def test_shared_item_model_survives_partial_bulk_failure_and_recovery(client):
+    evaluations, transport = client
+    item = EvaluationItem(model_version="model-b")
+    results = [
+        EvaluationResult(
+            item=item, scorer_version_id=uuid5(UUID(VERSION_ID), str(index)), value=True
+        )
+        for index in range(1001)
+    ]
+
+    def fail_second(method, path, *, body):
+        if transport.request.call_count == 2:
+            raise EvaluationAPIError(persistence="unknown")
+        return upload_response(body)
+
+    transport.request.side_effect = fail_second
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    with pytest.raises(BulkUploadError) as caught:
+        invoke(experiment.upload_results, results)
+    error = caught.value
+    assert len(error.completed.chunks[0].results) == 1000
+    assert error.failed_index == 1000
+    assert error.pending_results == (results[-1],)
+    assert error.failed_chunk["items"] == [item.to_dict()]
+    failed_body = transport.request.call_args.kwargs["body"]
+    error.failed_chunk["items"][0]["model_version"] = "changed"
+    assert error.failed_chunk["items"] == [item.to_dict()]
+    transport.request.side_effect = respond
+    invoke(experiment.upload_results, error.pending_results)
+    assert transport.request.call_args.kwargs["body"] == failed_body
+    assert transport.request.call_count == 3
+    for call in transport.request.call_args_list:
+        assert json.loads(call.kwargs["body"])["items"] == [item.to_dict()]
+
+
 def test_shared_item_is_redeclared_in_each_independently_replayable_chunk(
     client, monkeypatch
 ):
diff --git a/posthog/test/ai/test_evaluations_datasets.py b/posthog/test/ai/test_evaluations_datasets.py
index e90d34005..dfc40597c 100644
--- a/posthog/test/ai/test_evaluations_datasets.py
+++ b/posthog/test/ai/test_evaluations_datasets.py
@@ -648,6 +648,57 @@ def test_dataset_to_execution_copies_payload_and_keeps_trials_independent(client
         EvaluationItem.from_dataset_item(replace(case, archived=True))
 
 
+def test_dataset_executions_keep_explicit_models_and_never_infer_them(client):
+    evaluations, transport = client
+    transport.request.return_value = item_response(
+        metadata={"model_version": "source-model"}
+    )
+    case = invoke(evaluations.datasets.get_item, ITEM_ID)
+    transport.request.reset_mock()
+    items = [
+        EvaluationItem.from_dataset_item(case, output="Paris", model_version="model-b"),
+        EvaluationItem.from_dataset_item(case, output="Lyon", model_version="model-c"),
+        EvaluationItem.from_dataset_item(case),
+        EvaluationItem.from_dataset_item(case, model_version=None),
+    ]
+    assert len({item.id for item in items}) == 4
+    for item in items:
+        data = item.to_dict()
+        assert data["case_key"] == "capital-france"
+        assert data["dataset_item_version_id"] == VERSION_ID
+        assert data["payload"]["metadata"] == {"model_version": "source-model"}
+        assert EvaluationItem.from_dict(data).to_dict() == data
+    for invalid in ["", 1, True, "x" * 256]:
+        with pytest.raises(ValueError, match="model_version"):
+            EvaluationItem.from_dataset_item(case, model_version=invalid)
+    transport.request.assert_not_called()
+    transport.request.side_effect = respond_to_experiment
+    experiment = invoke(
+        evaluations.create_experiment, name="Models", model_version="model-a"
+    )
+    invoke(
+        experiment.upload_results,
+        [
+            EvaluationResult(item=item, scorer_version_id=OTHER_ITEM_ID, value=True)
+            for item in items
+        ],
+    )
+    body = json.loads(transport.request.call_args.kwargs["body"])
+    assert body["items"] == [item.to_dict() for item in items]
+    assert [item.get("model_version") for item in body["items"]] == [
+        "model-b",
+        "model-c",
+        None,
+        None,
+    ]
+    assert [item["payload"].get("output") for item in body["items"]] == [
+        "Paris",
+        "Lyon",
+        None,
+        None,
+    ]
+
+
 def test_dataset_scorer_experiment_flow_pins_both_versions_and_reuses_execution(client):
     evaluations, transport = client
     bodies = []
diff --git a/posthog/test/ai/test_evaluations_transport.py b/posthog/test/ai/test_evaluations_transport.py
index 3f62fe932..8f247f762 100644
--- a/posthog/test/ai/test_evaluations_transport.py
+++ b/posthog/test/ai/test_evaluations_transport.py
@@ -12,9 +12,16 @@
 import pytest
 import requests
 
+from posthog.ai.evaluations import (
+    AsyncOfflineEvaluations,
+    EvaluationItem,
+    OfflineEvaluations,
+)
 from posthog.ai.evaluations._errors import EvaluationAPIError
 from posthog.ai.evaluations._transport import AsyncTransport, SyncTransport
 
+from .test_evaluations import EXPERIMENT_ID, VERSION_ID, invoke, upload_response
+
 PATH = "/api/projects/123/ai_observability/offline_experiments/"
 BODY = b'{"id":"stable-id","name":"evaluation data"}'
 
@@ -102,6 +109,90 @@ def test_lost_response_retries_identical_body_and_identity(transport):
     sleep.assert_called_once()
 
 
+@pytest.mark.parametrize("asynchronous", [False, True], ids=["sync", "async"])
+@pytest.mark.parametrize(
+    "original_model,changed_model",
+    [("model-b", "model-c"), ("model-b", None), (None, "model-a")],
+)
+def test_item_models_survive_transport_retries_and_content_conflicts(
+    asynchronous, original_model, changed_model
+):
+    evaluations = (AsyncOfflineEvaluations if asynchronous else OfflineEvaluations)(
+        project_id=123, secret_key="phx_test_secret"
+    )
+    experiment = evaluations.resume_experiment(EXPERIMENT_ID)
+    item = EvaluationItem(model_version=original_model)
+    conflict = {
+        "code": "content_conflict",
+        "detail": "Item content differs from its accepted declaration.",
+        "attr": "items.0.model_version",
+    }
+    attempts = []
+
+    def respond(method, url, **kwargs):
+        body = kwargs["content" if asynchronous else "data"]
+        attempts.append((method, url, body))
+        if len(attempts) == 1:
+            raise (
+                httpx.ReadTimeout("lost response")
+                if asynchronous
+                else requests.ReadTimeout()
+            )
+        status, payload = (
+            (201, upload_response(body)) if len(attempts) == 2 else (409, conflict)
+        )
+        return (
+            httpx.Response(status, json=payload)
+            if asynchronous
+            else response(status, payload)
+        )
+
+    target = (
+        evaluations._transport._client
+        if asynchronous
+        else evaluations._transport._session
+    )
+    try:
+        with (
+            patch.object(target, "request", side_effect=respond),
+            patch("posthog.ai.evaluations._transport.time.sleep"),
+            patch(
+                "posthog.ai.evaluations._transport.asyncio.sleep",
+                new_callable=AsyncMock,
+            ),
+        ):
+            receipt = invoke(
+                experiment.upload_result,
+                item=item,
+                scorer_version_id=VERSION_ID,
+                value=True,
+            )
+            assert receipt.items[0].id == item.id
+            assert len(attempts) == 2
+            assert attempts[0] == attempts[1]
+            assert json.loads(attempts[0][2])["items"] == [item.to_dict()]
+            changed = EvaluationItem(id=item.id, model_version=changed_model)
+            with pytest.raises(EvaluationAPIError) as caught:
+                invoke(
+                    experiment.upload_result,
+                    item=changed,
+                    scorer_version_id=VERSION_ID,
+                    value=True,
+                )
+            assert caught.value.status == 409
+            assert caught.value.code == "content_conflict"
+            assert caught.value.response == conflict
+            assert caught.value.persistence == "rejected"
+            assert len(attempts) == 3
+            assert json.loads(attempts[2][2])["items"] == [changed.to_dict()]
+            assert all(
+                method == "POST" and url.endswith(f"/{EXPERIMENT_ID}/upload/")
+                for method, url, _ in attempts
+            )
+    finally:
+        invoke(evaluations.aclose if asynchronous else evaluations.close)
+
+
 @pytest.mark.parametrize("failure", [requests.ReadTimeout(), response(503)])
 def test_non_idempotent_mutation_never_replays(transport, failure):
     with (
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index feb33578b..25cbaa418 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1209,7 +1209,7 @@ class posthog.ai.evaluations.DatasetRevisionPage(count: int, results: tuple[Data
 class posthog.ai.evaluations.DatasetSnapshot(dataset: Dataset, revision: int, revision_id: str, _datasets: Datasets)
 class posthog.ai.evaluations.Datasets(transport: SyncTransport, project_id: int)
 class posthog.ai.evaluations.EvaluationAPIError(*, status: int | None = None, code: str | None = None, detail: Any = None, attr: str | None = None, errors: Any = None, response: dict[str, Any] | None = None, retry_after: float | None = None, persistence: Literal['rejected', 'unknown', 'not_sent'] = 'unknown', submission: dict[str, Any] | None = None)
-class posthog.ai.evaluations.EvaluationItem(*, id: str | UUID | None = None, input: JSONValue | _Unset = _UNSET, output: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | None | _Unset = _UNSET, case_key: str | None = None, trial: str | None = None, dataset_item_identifier: str | None = None, dataset_item_version_identifier: str | None = None, dataset_item_version_id: str | UUID | None = None, application_trace_id: str | None = None, payload: dict[str, JSONValue] | _Unset = _UNSET)
+class posthog.ai.evaluations.EvaluationItem(*, id: str | UUID | None = None, input: JSONValue | _Unset = _UNSET, output: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | None | _Unset = _UNSET, case_key: str | None = None, trial: str | None = None, dataset_item_identifier: str | None = None, dataset_item_version_identifier: str | None = None, dataset_item_version_id: str | UUID | None = None, application_trace_id: str | None = None, model_version: str | None = None, payload: dict[str, JSONValue] | _Unset = _UNSET)
 class posthog.ai.evaluations.EvaluationResult(*, item: EvaluationItem | str | UUID, scorer_version_id: str | UUID, value: ScoreValue | None = None, status: ResultStatus = 'ok', error_code: str | None = None, reasoning: str | None | _Unset = _UNSET, error_message: str | None | _Unset = _UNSET, metadata: dict[str, JSONValue] | None | _Unset = _UNSET, evaluator_trace_id: str | None = None, evaluated_at: datetime | str | None = None, payload: dict[str, JSONValue] | _Unset = _UNSET)
 class posthog.ai.evaluations.Experiment(transport: SyncTransport, project_id: int, id: str, *, receipt: ExperimentReceipt | None = None, submission: bytes | None = None)
 class posthog.ai.evaluations.ExperimentOptions
@@ -1622,7 +1622,7 @@ method posthog.ai.evaluations.Datasets.restore_item(item_id: str | UUID, *, base
 method posthog.ai.evaluations.Datasets.snapshot(dataset_id: str | UUID, *, revision: int | None = None)
 method posthog.ai.evaluations.Datasets.update(dataset_id: str | UUID, *, name: str | _Unset = _UNSET, description: str | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET, tags: Sequence[str] | _Unset = _UNSET)
 method posthog.ai.evaluations.Datasets.update_item(item_id: str | UUID, *, base_version: int, input: JSONValue | _Unset = _UNSET, expected_output: JSONValue | _Unset = _UNSET, metadata: dict[str, JSONValue] | _Unset = _UNSET)
-method posthog.ai.evaluations.EvaluationItem.from_dataset_item(item: DatasetItem, *, output: JSONValue | _Unset = _UNSET, id: str | UUID | None = None, case_key: str | None = None, trial: str | None = None, application_trace_id: str | None = None)
+method posthog.ai.evaluations.EvaluationItem.from_dataset_item(item: DatasetItem, *, output: JSONValue | _Unset = _UNSET, id: str | UUID | None = None, case_key: str | None = None, trial: str | None = None, application_trace_id: str | None = None, model_version: str | None = None)
 method posthog.ai.evaluations.EvaluationItem.from_dict(data: Mapping[str, Any])
 method posthog.ai.evaluations.EvaluationItem.to_dict()
 method posthog.ai.evaluations.EvaluationResult.from_dict(data: Mapping[str, Any], *, item: EvaluationItem | None = None)

From 7d15127fd4e3aeac72bb1af59f49d96c1c81be7e Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 27 Oct 2026 13:05:02 +0000
Subject: [PATCH 114/245] chore: Release v7.76.0 [skip ci]

---
 .sampo/changesets/jovial-shaman-kullervo.md | 5 -----
 openfeature-provider/CHANGELOG.md           | 6 ++++++
 openfeature-provider/pyproject.toml         | 2 +-
 posthog/CHANGELOG.md                        | 6 ++++++
 posthog/version.py                          | 2 +-
 pyproject.toml                              | 2 +-
 uv.lock                                     | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/jovial-shaman-kullervo.md

diff --git a/.sampo/changesets/jovial-shaman-kullervo.md b/.sampo/changesets/jovial-shaman-kullervo.md
deleted file mode 100644
index 1138e5cc2..000000000
--- a/.sampo/changesets/jovial-shaman-kullervo.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add optional per-item model_version to offline evaluations and dataset conversion, preserving model attribution across serialization, retries, and recovery.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 5f930ed78..599b78d5b 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.126 — 2026-10-27
+
+### Patch changes
+
+- Updated dependencies: posthog@7.76.0
+
 ## 0.1.125 — 2026-10-23
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 46b689f5e..86f6048f6 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.125"
+version = "0.1.126"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 32d74af17..de4696308 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.76.0 — 2026-10-27
+
+### Minor changes
+
+- [284340d](https://github.com/posthog/posthog-python/commit/284340d6ba6df08f68c27eac750b13f3ec89ab19) Add optional per-item model_version to offline evaluations and dataset conversion, preserving model attribution across serialization, retries, and recovery. — Thanks @Radu-Raicea!
+
 ## 7.75.11 — 2026-10-23
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 0d256d5f2..7fae9282a 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.75.11"
+VERSION = "7.76.0"
diff --git a/pyproject.toml b/pyproject.toml
index 013ab862a..851c242d4 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.75.11"
+version = "7.76.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 665480483..17bd3eff0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.125"
+version = "0.1.126"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3054,7 +3054,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.76.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 7833e95266da6130bf41028623f4a5e69a950d71 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 27 Oct 2026 13:05:10 +0000
Subject: [PATCH 115/245] Update generated references

---
 .../posthog-python-references-7.76.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.76.0.json

diff --git a/references/posthog-python-references-7.76.0.json b/references/posthog-python-references-7.76.0.json
new file mode 100644
index 000000000..9df82cc58
--- /dev/null
+++ b/references/posthog-python-references-7.76.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.76.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 00e8b9d05..9df82cc58 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.75.11",
+    "version": "7.76.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b0a2b59dc09e96903cdf97ea3c8ab5298bdff7bb Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Wed, 28 Oct 2026 04:40:27 -0400
Subject: [PATCH 116/245] feat(ai): record the Anthropic web search count in
 the LangChain callback handler (#1097)

* feat(ai): record the Anthropic web search count in the LangChain callback handler

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* chore: update public API snapshot for ModelUsage.web_search_count

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore: regenerate LangChain ModelUsage API snapshot

* fix(ai): read the LangChain web search count from llm_output usage and omit zero

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .../changesets/langchain-web-search-count.md  |  5 ++
 posthog/ai/langchain/callbacks.py             | 35 +++++++++++++
 posthog/test/ai/langchain/test_callbacks.py   | 51 +++++++++++++++++++
 references/public_api_snapshot.txt            |  3 +-
 4 files changed, 93 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/langchain-web-search-count.md

diff --git a/.sampo/changesets/langchain-web-search-count.md b/.sampo/changesets/langchain-web-search-count.md
new file mode 100644
index 000000000..465d4d912
--- /dev/null
+++ b/.sampo/changesets/langchain-web-search-count.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+The LangChain callback handler now records `$ai_web_search_count` for Anthropic responses that report `server_tool_use.web_search_requests`, as the OpenAI, Anthropic and Gemini wrappers and `posthog-js` already do.
diff --git a/posthog/ai/langchain/callbacks.py b/posthog/ai/langchain/callbacks.py
index 7c07d9314..757179aac 100644
--- a/posthog/ai/langchain/callbacks.py
+++ b/posthog/ai/langchain/callbacks.py
@@ -724,6 +724,8 @@ def _capture_generation(
                 )
             if usage.reasoning_tokens is not None:
                 event_properties["$ai_reasoning_tokens"] = usage.reasoning_tokens
+            if usage.web_search_count is not None and usage.web_search_count > 0:
+                event_properties["$ai_web_search_count"] = usage.web_search_count
 
             # Generation results
             generation_result = output.generations[-1]
@@ -856,6 +858,23 @@ class ModelUsage:
     reasoning_tokens: Optional[int]
     cache_write_5m_tokens: Optional[int] = None
     cache_write_1h_tokens: Optional[int] = None
+    web_search_count: Optional[int] = None
+
+
+def _extract_web_search_requests(usage: Union[BaseModel, dict]) -> Optional[int]:
+    if isinstance(usage, BaseModel):
+        usage = usage.__dict__
+    server_tool_use = usage.get("server_tool_use")
+    web_search_requests = (
+        server_tool_use.get("web_search_requests")
+        if isinstance(server_tool_use, dict)
+        else getattr(server_tool_use, "web_search_requests", None)
+    )
+    if isinstance(web_search_requests, int) and not isinstance(
+        web_search_requests, bool
+    ):
+        return web_search_requests
+    return None
 
 
 def _parse_usage_model(
@@ -924,6 +943,11 @@ def _parse_usage_model(
     ):
         parsed_usage["reasoning"] = usage["output_token_details"].get("reasoning")
 
+    # Anthropic reports the exact number of web searches of a response
+    web_search_requests = _extract_web_search_requests(usage)
+    if web_search_requests is not None:
+        parsed_usage["web_search"] = web_search_requests
+
     field_mapping = {
         "input": "input_tokens",
         "output": "output_tokens",
@@ -938,6 +962,7 @@ def _parse_usage_model(
         },
         cache_write_5m_tokens=parsed_usage.get("cache_write_5m"),
         cache_write_1h_tokens=parsed_usage.get("cache_write_1h"),
+        web_search_count=parsed_usage.get("web_search"),
     )
     # For Anthropic providers, LangChain reports input_tokens as the sum of all input tokens.
     # Our cost calculation expects them to be separate for Anthropic, so we subtract cache tokens.
@@ -975,12 +1000,19 @@ def _parse_usage(
         reasoning_tokens=None,
     )
 
+    # The generations loop below can replace the llm_output usage, which is the
+    # only place langchain-anthropic reports server_tool_use, so read it here.
+    web_search_count: Optional[int] = None
+
     if response.llm_output is not None:
         for key in llm_usage_keys:
             if response.llm_output.get(key):
                 llm_usage = _parse_usage_model(
                     response.llm_output[key], provider, model
                 )
+                web_search_count = _extract_web_search_requests(
+                    response.llm_output[key]
+                )
                 break
 
     if hasattr(response, "generations"):
@@ -1026,6 +1058,9 @@ def _parse_usage(
                     llm_usage = _parse_usage_model(chunk_usage, provider, model)
                     break
 
+    if llm_usage.web_search_count is None:
+        llm_usage.web_search_count = web_search_count
+
     return llm_usage
 
 
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index 4c4de1be2..f5fbbcbe3 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -2965,6 +2965,57 @@ def test_stop_reason_resolution(
     assert props.get("$ai_stop_reason") == expected
 
 
+@pytest.mark.parametrize(
+    "server_tool_use,expected",
+    [
+        # Anthropic reports the exact number of searches
+        ({"web_search_requests": 2}, 2),
+        # no search is not worth an event property
+        ({"web_search_requests": 0}, None),
+        # the provider reports nothing
+        (None, None),
+    ],
+)
+def test_web_search_count(mock_client, server_tool_use, expected):
+    from langchain_core.outputs import ChatGeneration, LLMResult
+
+    cb = CallbackHandler(mock_client)
+    run_id = uuid.uuid4()
+    cb._set_llm_metadata(
+        serialized={},
+        run_id=run_id,
+        messages=[{"role": "user", "content": "test"}],
+        metadata={"ls_provider": "anthropic", "ls_model_name": "claude-sonnet"},
+    )
+    usage = {"input_tokens": 10, "output_tokens": 5}
+    if server_tool_use is not None:
+        usage["server_tool_use"] = server_tool_use
+    # langchain-anthropic always sets usage_metadata on the message, which the
+    # generations loop prefers over llm_output["usage"]
+    response = LLMResult(
+        generations=[
+            [
+                ChatGeneration(
+                    message=AIMessage(
+                        content="r",
+                        usage_metadata={
+                            "input_tokens": 10,
+                            "output_tokens": 5,
+                            "total_tokens": 15,
+                        },
+                    )
+                )
+            ]
+        ],
+        llm_output={"usage": usage},
+    )
+
+    cb._pop_run_and_capture_generation(run_id, None, response)
+
+    props = mock_client.capture.call_args.kwargs["properties"]
+    assert props.get("$ai_web_search_count") == expected
+
+
 class TestGetHttpStatus:
     def test_uses_the_status_code_of_an_http_error(self):
         from posthog.ai.langchain.callbacks import _get_http_status
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 25cbaa418..425ea779f 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -596,6 +596,7 @@ attribute posthog.ai.langchain.callbacks.ModelUsage.cache_write_tokens: Optional
 attribute posthog.ai.langchain.callbacks.ModelUsage.input_tokens: Optional[int]
 attribute posthog.ai.langchain.callbacks.ModelUsage.output_tokens: Optional[int]
 attribute posthog.ai.langchain.callbacks.ModelUsage.reasoning_tokens: Optional[int]
+attribute posthog.ai.langchain.callbacks.ModelUsage.web_search_count: Optional[int] = None
 attribute posthog.ai.langchain.callbacks.RunMetadata = Union[SpanMetadata, GenerationMetadata]
 attribute posthog.ai.langchain.callbacks.RunMetadataStorage = Dict[UUID, RunMetadata]
 attribute posthog.ai.langchain.callbacks.SpanMetadata.end_time: Optional[float]
@@ -1234,7 +1235,7 @@ class posthog.ai.gemini.gemini_converter.GeminiMessage
 class posthog.ai.gemini.gemini_converter.GeminiPart 
 class posthog.ai.langchain.callbacks.CallbackHandler(client: Optional[Client] = None, *, distinct_id: Optional[Union[str, int, UUID]] = None, trace_id: Optional[Union[str, int, float, UUID]] = None, properties: Optional[Dict[str, Any]] = None, privacy_mode: bool = False, groups: Optional[Dict[str, Any]] = None)
 class posthog.ai.langchain.callbacks.GenerationMetadata(name: str, start_time: float, end_time: Optional[float], input: Optional[Any], provider: Optional[str] = None, model: Optional[str] = None, model_params: Optional[Dict[str, Any]] = None, base_url: Optional[str] = None, tools: Optional[List[Dict[str, Any]]] = None, posthog_properties: Optional[Dict[str, Any]] = None)
-class posthog.ai.langchain.callbacks.ModelUsage(input_tokens: Optional[int], output_tokens: Optional[int], cache_write_tokens: Optional[int], cache_read_tokens: Optional[int], reasoning_tokens: Optional[int], cache_write_5m_tokens: Optional[int] = None, cache_write_1h_tokens: Optional[int] = None)
+class posthog.ai.langchain.callbacks.ModelUsage(input_tokens: Optional[int], output_tokens: Optional[int], cache_write_tokens: Optional[int], cache_read_tokens: Optional[int], reasoning_tokens: Optional[int], cache_write_5m_tokens: Optional[int] = None, cache_write_1h_tokens: Optional[int] = None, web_search_count: Optional[int] = None)
 class posthog.ai.langchain.callbacks.SpanMetadata(name: str, start_time: float, end_time: Optional[float], input: Optional[Any])
 class posthog.ai.langchain.middleware.PostHogMiddleware(client: Optional[Client] = None, *, distinct_id: Optional[Union[str, int, UUID]] = None, trace_id: Optional[Union[str, int, float, UUID]] = None, properties: Optional[dict[str, Any]] = None, privacy_mode: bool = False, groups: Optional[dict[str, Any]] = None)
 class posthog.ai.openai.openai.OpenAI(posthog_client: Optional[PostHogClient] = None, **kwargs)

From a736b43290fc88fecc929916887a3c1c215984a7 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 09:26:46 +0000
Subject: [PATCH 117/245] chore: Release v7.76.1 [skip ci]

---
 .sampo/changesets/langchain-web-search-count.md | 5 -----
 openfeature-provider/CHANGELOG.md               | 6 ++++++
 openfeature-provider/pyproject.toml             | 2 +-
 posthog/CHANGELOG.md                            | 6 ++++++
 posthog/version.py                              | 2 +-
 pyproject.toml                                  | 2 +-
 uv.lock                                         | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/langchain-web-search-count.md

diff --git a/.sampo/changesets/langchain-web-search-count.md b/.sampo/changesets/langchain-web-search-count.md
deleted file mode 100644
index 465d4d912..000000000
--- a/.sampo/changesets/langchain-web-search-count.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-The LangChain callback handler now records `$ai_web_search_count` for Anthropic responses that report `server_tool_use.web_search_requests`, as the OpenAI, Anthropic and Gemini wrappers and `posthog-js` already do.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 599b78d5b..6490a4fd7 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.127 — 2026-10-28
+
+### Patch changes
+
+- Updated dependencies: posthog@7.76.1
+
 ## 0.1.126 — 2026-10-27
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 86f6048f6..c46ba15fb 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.126"
+version = "0.1.127"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index de4696308..142ff2135 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.76.1 — 2026-10-28
+
+### Patch changes
+
+- [b0a2b59](https://github.com/posthog/posthog-python/commit/b0a2b59dc09e96903cdf97ea3c8ab5298bdff7bb) The LangChain callback handler now records `$ai_web_search_count` for Anthropic responses that report `server_tool_use.web_search_requests`, as the OpenAI, Anthropic and Gemini wrappers and `posthog-js` already do. — Thanks @pcbeingused333!
+
 ## 7.76.0 — 2026-10-27
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 7fae9282a..4d481543d 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.76.0"
+VERSION = "7.76.1"
diff --git a/pyproject.toml b/pyproject.toml
index 851c242d4..4b8ec95c1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.76.0"
+version = "7.76.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 17bd3eff0..7487f21ec 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.126"
+version = "0.1.127"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3054,7 +3054,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.76.0"
+version = "7.76.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 3044d8ed5919b6b11b42642359651855c6f9ec38 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 09:26:52 +0000
Subject: [PATCH 118/245] Update generated references

---
 .../posthog-python-references-7.76.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.76.1.json

diff --git a/references/posthog-python-references-7.76.1.json b/references/posthog-python-references-7.76.1.json
new file mode 100644
index 000000000..966c6f297
--- /dev/null
+++ b/references/posthog-python-references-7.76.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.76.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 9df82cc58..966c6f297 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.76.0",
+    "version": "7.76.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From d8a1b976d665d9f7b3249ac788ef253bb21eed50 Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Wed, 28 Oct 2026 12:33:42 +0200
Subject: [PATCH 119/245] feat(mcp): add a send_initialize_event option (#1115)

* feat(mcp): add a capture_initialize option

MCPAnalyticsOptions(capture_initialize=False) stops $mcp_initialize. The
option is on by default. Many clients reconnect before every few tool
calls, so the handshake event can outnumber $mcp_tool_call.

With the option off, record_initialize and the first-request fallback
return early. Nothing else changes: the middleware still mints the
session token, so tool calls keep their sessions and client names.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): keep the handshake identity with capture_initialize off

record_initialize returned before handle_identify when the option was
off. An identify callback that resolves the user only from the
initialize request then left the session anonymous, so later tool calls
lost the user. Identify now runs first, and the option stops only the
event.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(mcp): rename capture_initialize to send_initialize_event

PostHogMCP already has a capture_initialize() method that sends the
event by hand. An option with the same name next to that method makes
readers link the two. The new name says what the option controls.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(mcp): name the PostHog screens that read $mcp_initialize

MCP onboarding and the users and sessions tiles of the default MCP
dashboard read $mcp_initialize. The README now says that they show no
data while send_initialize_event is off.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../mcp-capture-initialize-option.md          |  5 ++
 posthog/mcp/README.md                         | 14 +++-
 posthog/mcp/_instrumentation.py               | 11 ++-
 posthog/mcp/types.py                          |  3 +
 posthog/test/mcp/test_initialize_handshake.py | 74 +++++++++++++++++++
 references/public_api_snapshot.txt            |  3 +-
 6 files changed, 105 insertions(+), 5 deletions(-)
 create mode 100644 .sampo/changesets/mcp-capture-initialize-option.md

diff --git a/.sampo/changesets/mcp-capture-initialize-option.md b/.sampo/changesets/mcp-capture-initialize-option.md
new file mode 100644
index 000000000..68efa0a0b
--- /dev/null
+++ b/.sampo/changesets/mcp-capture-initialize-option.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add a `send_initialize_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_initialize`.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index 7f3133f2f..f1c0e362c 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -41,8 +41,8 @@ Use a client dedicated to MCP analytics if the application also captures unrelat
 A valid echoed conversation handle takes precedence over transport sessions. A request that already carries a transport session or a PostHog session token does not mint a new handle or append a prompt-back block. Requests carrying neither use the conversation fallback.
 
 
-Intent, model capture, conversation correlation, and MCP exception capture are on by default.
-Missing-capability reporting and feedback collection remain off.
+Intent, model capture, conversation correlation, MCP exception capture, and `$mcp_initialize`
+are on by default. Missing-capability reporting and feedback collection remain off.
 
 ```python
 from posthog.mcp import MCPAnalyticsOptions, instrument
@@ -88,6 +88,16 @@ The MCP SDK answers `initialize` itself, so the SDK observes it from outside:
 - **MCP SDK 1.x over stdio**: from the session's first request. A stdio server
   serves one client, so this misses only a client that never sends a request.
 
+Set `send_initialize_event=False` to stop sending `$mcp_initialize`. Many clients reconnect before
+every few tool calls, so this event can outnumber `$mcp_tool_call`. Nothing else changes in what
+the SDK sends: tool calls keep their sessions and client names. In PostHog, MCP onboarding and the
+users and sessions tiles of the default MCP dashboard read `$mcp_initialize`. They show no data
+while the option is off.
+
+```python
+instrument(server, posthog, MCPAnalyticsOptions(send_initialize_event=False))
+```
+
 `identify` and `event_properties` run for the handshake too. On MCP SDK 1.x the
 SDK has no request context for it, so `extra["ctx"]` carries only `.request`.
 `get_request_headers(extra)` works the same as for any other request.
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index 4e72e1de1..37877380f 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -260,14 +260,19 @@ async def record_initialize(
     stateless fleet may never see this client again. The capture itself runs after,
     in the background, as for every other event."""
 
+    request = {"method": "initialize", "params": params}
+    await handle_identify(data, session_id, request, extra)
+    # The option stops only the event. Identify still runs, so later events of
+    # the session keep an identity that only the handshake can resolve.
+    if not data.options.send_initialize_event:
+        return
+
     def text(value: Any) -> Optional[str]:
         return value if isinstance(value, str) and value else None
 
     client_info = params.get("clientInfo")
     client_info = client_info if isinstance(client_info, dict) else {}
     agreed = result.get("protocolVersion") if isinstance(result, dict) else None
-    request = {"method": "initialize", "params": params}
-    await handle_identify(data, session_id, request, extra)
     data.mark_session_initialized(session_id)
     event: Dict[str, Any] = {
         "event_type": MCPAnalyticsEventType.MCP_INITIALIZE,
@@ -321,6 +326,8 @@ async def _maybe_emit_initialize(
     """Emit ``$mcp_initialize`` once per session from its first request, where no
     seam observes the real ``initialize`` (see
     :func:`_first_request_stands_in_for_initialize`)."""
+    if not data.options.send_initialize_event:
+        return
     if not _first_request_stands_in_for_initialize(data, session_source, extra):
         return
     if session_id in data.initialized_sessions:
diff --git a/posthog/mcp/types.py b/posthog/mcp/types.py
index 7db240edb..8dbaaf88c 100644
--- a/posthog/mcp/types.py
+++ b/posthog/mcp/types.py
@@ -246,6 +246,9 @@ class MCPAnalyticsOptions:
     # its input schema to remove only PostHog-owned arguments on a fresh server
     # instance that did not serve tools/list.
     resolve_original_tool: Optional[Callable[[str], Any]] = None
+    # Send `$mcp_initialize` for each `initialize` handshake. On by default.
+    # False sends no `$mcp_initialize`. Nothing else changes.
+    send_initialize_event: bool = True
 
 
 @dataclass
diff --git a/posthog/test/mcp/test_initialize_handshake.py b/posthog/test/mcp/test_initialize_handshake.py
index 022235fa1..7d6a41b5f 100644
--- a/posthog/test/mcp/test_initialize_handshake.py
+++ b/posthog/test/mcp/test_initialize_handshake.py
@@ -988,3 +988,77 @@ async def test_a_nested_method_before_the_top_level_initialize_is_counted(kind):
     assert response.status_code == 200, response.text
     (init,) = _events(client, "$mcp_initialize")
     assert init["properties"]["$mcp_client_name"] == "nested-client"
+
+
+# --- send_initialize_event=False -----------------------------------------------------
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_send_initialize_event_off_sends_no_initialize_and_keeps_sessions(kind):
+    # The multi-pod scenario with the option off: no $mcp_initialize. Nothing else
+    # changes: the token is still minted, so each connection's tool calls keep its
+    # session and its client name on every pod.
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False, send_initialize_event=False
+    )
+    sessions = []
+    async with fleet(client, pods=2, kind=kind, options=options) as lb:
+        for _ in range(2):
+            headers, _ = await handshake(lb)
+            token = decode_session_id(headers.get("mcp-session-id"))
+            assert token is not None
+            sessions.append(token.session_id)
+            await list_tools(lb, headers)
+            await call_add(lb, headers, 3)
+            await call_add(lb, headers, 4)
+    await _flush()
+
+    assert _events(client, "$mcp_initialize") == []
+    calls = _events(client, "$mcp_tool_call")
+    assert [c["properties"]["$session_id"] for c in calls] == [
+        sessions[0],
+        sessions[0],
+        sessions[1],
+        sessions[1],
+    ]
+    assert {c["properties"]["$mcp_client_name"] for c in calls} == {"codex-mcp-client"}
+
+
+@pytest.mark.parametrize("kind", KINDS)
+async def test_send_initialize_event_off_keeps_the_handshake_identity(kind):
+    # The option stops only the event. An identify that resolves the user only
+    # from the handshake still attributes the session's later tool calls.
+    def identify(request, extra):
+        if request.get("method") == "initialize":
+            return UserIdentity(distinct_id="user_from_handshake")
+        return None
+
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False, identify=identify, send_initialize_event=False
+    )
+    async with fleet(client, kind=kind, options=options) as lb:
+        headers, _ = await handshake(lb)
+        await call_add(lb, headers)
+    await _flush()
+
+    assert _events(client, "$mcp_initialize") == []
+    (call,) = _events(client, "$mcp_tool_call")
+    assert call["distinct_id"] == "user_from_handshake"
+
+
+@pytest.mark.skipif(MCP_MAJOR >= 2, reason="the first-request fallback is mcp 1.x")
+@pytest.mark.parametrize("capture", [True, False])
+async def test_send_initialize_event_off_also_gates_the_first_request_fallback(capture):
+    # No HTTP, as on stdio: the first tool call stands in for the handshake.
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False, send_initialize_event=capture
+    )
+    _, _, server = make_pod(client, options=options)
+    await server._tool_manager.call_tool("add", {"a": 1, "b": 2, "context": "stdio"})
+    await _flush()
+
+    assert len(_events(client, "$mcp_tool_call")) == 1
+    assert len(_events(client, "$mcp_initialize")) == (1 if capture else 0)
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 425ea779f..91fb0c168 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1055,6 +1055,7 @@ attribute posthog.mcp.types.MCPAnalyticsOptions.missing_capability_tool_name: Op
 attribute posthog.mcp.types.MCPAnalyticsOptions.report_missing: bool = False
 attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_input_aliases: Optional[ResolveInputAliasesFn] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_original_tool: Optional[Callable[[str], Any]] = None
+attribute posthog.mcp.types.MCPAnalyticsOptions.send_initialize_event: bool = True
 attribute posthog.mcp.types.MCPAnalyticsOptions.server_build: Optional[str] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.should_record_input_key: Optional[ShouldRecordInputKeyFn] = None
 attribute posthog.mcp.types.PreparedToolCall.args: Optional[JsonRecord] = None
@@ -1309,7 +1310,7 @@ class posthog.mcp.types.CollectFeedbackOptions(tool_name: Optional[str] = None,
 class posthog.mcp.types.FeedbackReport(feedback_type: str = 'other', summary: str = '', sentiment: Optional[str] = None, friction_points: Optional[str] = None, suggested_improvement: Optional[str] = None, details: Optional[str] = None, tool_name: Optional[str] = None, task_completed: Optional[bool] = None, extras: JsonRecord = dict(), raw: JsonRecord = dict())
 class posthog.mcp.types.MCPAnalyticsContextOptions(description: Optional[str] = None)
 class posthog.mcp.types.MCPAnalyticsModelOptions(description: Optional[str] = None)
-class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None, resolve_original_tool: Optional[Callable[[str], Any]] = None)
+class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None, resolve_original_tool: Optional[Callable[[str], Any]] = None, send_initialize_event: bool = True)
 class posthog.mcp.types.PreparedToolCall(args: Optional[JsonRecord] = None, intent: Optional[str] = None, intent_source: Optional[str] = None, is_missing_capability: bool = False, llm_model: Optional[str] = None, llm_model_source: Optional[MCPAnalyticsModelSource] = None, is_feedback: bool = False, feedback_report: Optional[FeedbackReport] = None, session_id: Optional[str] = None, conversation_id: Optional[str] = None, _conversation_state: Optional[PreparedConversationState] = None)
 class posthog.mcp.types.ToolInputOptions(should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, input_aliases: Optional[InputAliasMap] = None)
 class posthog.mcp.types.UserIdentity(distinct_id: str, properties: Optional[JsonRecord] = None, groups: Optional[Dict[str, str]] = None)

From 786db579d383a34fc6b4d21d1332743b5eec17b5 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:23:07 +0000
Subject: [PATCH 120/245] chore: Release v7.77.0 [skip ci]

---
 .sampo/changesets/mcp-capture-initialize-option.md | 5 -----
 openfeature-provider/CHANGELOG.md                  | 6 ++++++
 openfeature-provider/pyproject.toml                | 2 +-
 posthog/CHANGELOG.md                               | 6 ++++++
 posthog/version.py                                 | 2 +-
 pyproject.toml                                     | 2 +-
 uv.lock                                            | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-capture-initialize-option.md

diff --git a/.sampo/changesets/mcp-capture-initialize-option.md b/.sampo/changesets/mcp-capture-initialize-option.md
deleted file mode 100644
index 68efa0a0b..000000000
--- a/.sampo/changesets/mcp-capture-initialize-option.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add a `send_initialize_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_initialize`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 6490a4fd7..9a8af7471 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.128 — 2026-10-28
+
+### Patch changes
+
+- Updated dependencies: posthog@7.77.0
+
 ## 0.1.127 — 2026-10-28
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index c46ba15fb..6593702ab 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.127"
+version = "0.1.128"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 142ff2135..5cf1cd2be 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.77.0 — 2026-10-28
+
+### Minor changes
+
+- [d8a1b97](https://github.com/posthog/posthog-python/commit/d8a1b976d665d9f7b3249ac788ef253bb21eed50) Add a `send_initialize_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_initialize`. — Thanks @gesh!
+
 ## 7.76.1 — 2026-10-28
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 4d481543d..7b925de06 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.76.1"
+VERSION = "7.77.0"
diff --git a/pyproject.toml b/pyproject.toml
index 4b8ec95c1..af8a2f1fe 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.76.1"
+version = "7.77.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 7487f21ec..f402ec702 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.127"
+version = "0.1.128"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3054,7 +3054,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.76.1"
+version = "7.77.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 0894015a3730c8bbdf1cfc3276da12913bcdac27 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:23:12 +0000
Subject: [PATCH 121/245] Update generated references

---
 .../posthog-python-references-7.77.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.77.0.json

diff --git a/references/posthog-python-references-7.77.0.json b/references/posthog-python-references-7.77.0.json
new file mode 100644
index 000000000..70871253b
--- /dev/null
+++ b/references/posthog-python-references-7.77.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.77.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 966c6f297..70871253b 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.76.1",
+    "version": "7.77.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 351da59c252afb7bffed79d21c23aa7e2539a38e Mon Sep 17 00:00:00 2001
From: Georgis Andonis <6430745+gesh@users.noreply.github.com>
Date: Wed, 28 Oct 2026 15:54:22 +0200
Subject: [PATCH 122/245] feat(mcp): add a send_tools_list_event option (#1116)

MCPAnalyticsOptions(send_tools_list_event=False) stops $mcp_tools_list.
The option is on by default. Clients list tools on every reconnect, so
the listing event is about as common as $mcp_tool_call.

With the option off, record_tools_list returns early, which also drops a
failed listing's $exception. Nothing else changes: tools keep their
injected arguments, and the virtual tools stay listed.

The name says "event" to match send_initialize_event.
PostHogMCP.capture_tools_list() already captures the event by hand.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../mcp-capture-tools-list-option.md          |  5 ++
 posthog/mcp/README.md                         |  3 +
 posthog/mcp/_instrumentation.py               |  2 +
 posthog/mcp/types.py                          |  4 ++
 .../test/mcp/test_send_tools_list_event.py    | 68 +++++++++++++++++++
 references/public_api_snapshot.txt            |  3 +-
 6 files changed, 84 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/mcp-capture-tools-list-option.md
 create mode 100644 posthog/test/mcp/test_send_tools_list_event.py

diff --git a/.sampo/changesets/mcp-capture-tools-list-option.md b/.sampo/changesets/mcp-capture-tools-list-option.md
new file mode 100644
index 000000000..0208e7620
--- /dev/null
+++ b/.sampo/changesets/mcp-capture-tools-list-option.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add a `send_tools_list_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_tools_list`.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index f1c0e362c..bd179597d 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -98,6 +98,9 @@ while the option is off.
 instrument(server, posthog, MCPAnalyticsOptions(send_initialize_event=False))
 ```
 
+Set `send_tools_list_event=False` to stop sending `$mcp_tools_list`. Nothing else changes: tools
+keep their injected arguments, and the virtual tools stay listed.
+
 `identify` and `event_properties` run for the handshake too. On MCP SDK 1.x the
 SDK has no request context for it, so `extra["ctx"]` carries only `.request`.
 `get_request_headers(extra)` works the same as for any other request.
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index 37877380f..cd87dd4a2 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -1449,6 +1449,8 @@ async def record_tools_list(
     protocol_version: Optional[str] = None,
     extra: Optional[Dict[str, Any]] = None,
 ) -> None:
+    if not data.options.send_tools_list_event:
+        return
     try:
         event: Dict[str, Any] = {
             "event_type": MCPAnalyticsEventType.MCP_TOOLS_LIST,
diff --git a/posthog/mcp/types.py b/posthog/mcp/types.py
index 8dbaaf88c..04d1256c8 100644
--- a/posthog/mcp/types.py
+++ b/posthog/mcp/types.py
@@ -249,6 +249,10 @@ class MCPAnalyticsOptions:
     # Send `$mcp_initialize` for each `initialize` handshake. On by default.
     # False sends no `$mcp_initialize`. Nothing else changes.
     send_initialize_event: bool = True
+    # Send `$mcp_tools_list` for each `tools/list`. On by default. False sends
+    # no `$mcp_tools_list`. Nothing else changes: tools keep their injected
+    # arguments, and the virtual tools stay listed.
+    send_tools_list_event: bool = True
 
 
 @dataclass
diff --git a/posthog/test/mcp/test_send_tools_list_event.py b/posthog/test/mcp/test_send_tools_list_event.py
new file mode 100644
index 000000000..7f41b3f5e
--- /dev/null
+++ b/posthog/test/mcp/test_send_tools_list_event.py
@@ -0,0 +1,68 @@
+"""``send_tools_list_event=False`` sends no ``$mcp_tools_list``, and nothing else changes.
+
+Reuses the real-HTTP fleet from ``test_initialize_handshake.py``, so it runs for
+every server shape on both SDK majors.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from posthog.mcp import MCPAnalyticsOptions, instrument
+from posthog.test.mcp._helpers import (
+    MCP_MAJOR,
+    FakeClient,
+    events_named as _events,
+    flush_background as _flush,
+)
+from posthog.test.mcp.test_initialize_handshake import (
+    KINDS,
+    call_add,
+    fleet,
+    handshake,
+    list_tools,
+)
+
+
+@pytest.mark.parametrize("kind", KINDS)
+@pytest.mark.parametrize("capture", [True, False])
+async def test_send_tools_list_event_controls_only_the_listing_event(kind, capture):
+    client = FakeClient()
+    options = MCPAnalyticsOptions(
+        enable_conversation_id=False, send_tools_list_event=capture
+    )
+    async with fleet(client, kind=kind, options=options) as lb:
+        headers, _ = await handshake(lb)
+        listing = (await list_tools(lb, headers)).json()["result"]
+        await call_add(lb, headers)
+    await _flush()
+
+    assert len(_events(client, "$mcp_tools_list")) == (1 if capture else 0)
+    # The listing itself is unchanged: the SDK still injects `context`.
+    (tool,) = [t for t in listing["tools"] if t["name"] == "add"]
+    assert "context" in tool["inputSchema"]["properties"]
+    (call,) = _events(client, "$mcp_tool_call")
+    assert call["properties"]["$mcp_intent"] == "adding"
+    assert len(_events(client, "$mcp_initialize")) == 1
+
+
+@pytest.mark.skipif(MCP_MAJOR >= 2, reason="the request_handlers registry is mcp 1.x")
+async def test_send_tools_list_event_off_also_drops_a_failed_listing():
+    import mcp.types as mcp_types
+    from mcp.server.lowlevel import Server
+
+    server = Server("failing-listing")
+
+    @server.list_tools()
+    async def list_tools_handler():
+        raise RuntimeError("listing failed")
+
+    client = FakeClient()
+    instrument(server, client, MCPAnalyticsOptions(send_tools_list_event=False))
+    handler = server.request_handlers[mcp_types.ListToolsRequest]
+    with pytest.raises(RuntimeError):
+        await handler(mcp_types.ListToolsRequest(method="tools/list"))
+    await _flush()
+
+    assert _events(client, "$mcp_tools_list") == []
+    assert _events(client, "$exception") == []
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 91fb0c168..6c7ff2b92 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1056,6 +1056,7 @@ attribute posthog.mcp.types.MCPAnalyticsOptions.report_missing: bool = False
 attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_input_aliases: Optional[ResolveInputAliasesFn] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.resolve_original_tool: Optional[Callable[[str], Any]] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.send_initialize_event: bool = True
+attribute posthog.mcp.types.MCPAnalyticsOptions.send_tools_list_event: bool = True
 attribute posthog.mcp.types.MCPAnalyticsOptions.server_build: Optional[str] = None
 attribute posthog.mcp.types.MCPAnalyticsOptions.should_record_input_key: Optional[ShouldRecordInputKeyFn] = None
 attribute posthog.mcp.types.PreparedToolCall.args: Optional[JsonRecord] = None
@@ -1310,7 +1311,7 @@ class posthog.mcp.types.CollectFeedbackOptions(tool_name: Optional[str] = None,
 class posthog.mcp.types.FeedbackReport(feedback_type: str = 'other', summary: str = '', sentiment: Optional[str] = None, friction_points: Optional[str] = None, suggested_improvement: Optional[str] = None, details: Optional[str] = None, tool_name: Optional[str] = None, task_completed: Optional[bool] = None, extras: JsonRecord = dict(), raw: JsonRecord = dict())
 class posthog.mcp.types.MCPAnalyticsContextOptions(description: Optional[str] = None)
 class posthog.mcp.types.MCPAnalyticsModelOptions(description: Optional[str] = None)
-class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None, resolve_original_tool: Optional[Callable[[str], Any]] = None, send_initialize_event: bool = True)
+class posthog.mcp.types.MCPAnalyticsOptions(logger: Optional[LoggerFn] = None, report_missing: bool = False, missing_capability_tool_name: Optional[str] = None, enable_conversation_id: bool = True, enable_exception_autocapture: bool = True, context: Union[bool, MCPAnalyticsContextOptions] = True, identify: Optional[Union[IdentifyFn, UserIdentity]] = None, intent_fallback: Optional[IntentFallbackFn] = None, before_send: Optional[BeforeSendFn] = None, event_properties: Optional[EventPropertiesFn] = None, capture_model: Union[bool, MCPAnalyticsModelOptions] = True, collect_feedback: Union[bool, CollectFeedbackOptions] = False, server_build: Optional[str] = None, should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, resolve_input_aliases: Optional[ResolveInputAliasesFn] = None, resolve_original_tool: Optional[Callable[[str], Any]] = None, send_initialize_event: bool = True, send_tools_list_event: bool = True)
 class posthog.mcp.types.PreparedToolCall(args: Optional[JsonRecord] = None, intent: Optional[str] = None, intent_source: Optional[str] = None, is_missing_capability: bool = False, llm_model: Optional[str] = None, llm_model_source: Optional[MCPAnalyticsModelSource] = None, is_feedback: bool = False, feedback_report: Optional[FeedbackReport] = None, session_id: Optional[str] = None, conversation_id: Optional[str] = None, _conversation_state: Optional[PreparedConversationState] = None)
 class posthog.mcp.types.ToolInputOptions(should_record_input_key: Optional[ShouldRecordInputKeyFn] = None, input_aliases: Optional[InputAliasMap] = None)
 class posthog.mcp.types.UserIdentity(distinct_id: str, properties: Optional[JsonRecord] = None, groups: Optional[Dict[str, str]] = None)

From 39110204fdf2aceb1e00f66f18bd5656f0783aff Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:01:03 +0000
Subject: [PATCH 123/245] chore: Release v7.78.0 [skip ci]

---
 .sampo/changesets/mcp-capture-tools-list-option.md | 5 -----
 openfeature-provider/CHANGELOG.md                  | 6 ++++++
 openfeature-provider/pyproject.toml                | 2 +-
 posthog/CHANGELOG.md                               | 6 ++++++
 posthog/version.py                                 | 2 +-
 pyproject.toml                                     | 2 +-
 uv.lock                                            | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-capture-tools-list-option.md

diff --git a/.sampo/changesets/mcp-capture-tools-list-option.md b/.sampo/changesets/mcp-capture-tools-list-option.md
deleted file mode 100644
index 0208e7620..000000000
--- a/.sampo/changesets/mcp-capture-tools-list-option.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add a `send_tools_list_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_tools_list`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 9a8af7471..8ab8f1da8 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.129 — 2026-10-28
+
+### Patch changes
+
+- Updated dependencies: posthog@7.78.0
+
 ## 0.1.128 — 2026-10-28
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 6593702ab..36422e109 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.128"
+version = "0.1.129"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5cf1cd2be..c8eb695ac 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.78.0 — 2026-10-28
+
+### Minor changes
+
+- [351da59](https://github.com/posthog/posthog-python/commit/351da59c252afb7bffed79d21c23aa7e2539a38e) Add a `send_tools_list_event` option to MCP analytics. It is on by default. Set it to `False` to stop sending `$mcp_tools_list`. — Thanks @gesh!
+
 ## 7.77.0 — 2026-10-28
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 7b925de06..a1744501a 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.77.0"
+VERSION = "7.78.0"
diff --git a/pyproject.toml b/pyproject.toml
index af8a2f1fe..ce79329d0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.77.0"
+version = "7.78.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index f402ec702..297ff4dc6 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.128"
+version = "0.1.129"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3054,7 +3054,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.77.0"
+version = "7.78.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 75a17943805604a040ac2f204fd74e3fbeb501a3 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 14:01:09 +0000
Subject: [PATCH 124/245] Update generated references

---
 .../posthog-python-references-7.78.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.78.0.json

diff --git a/references/posthog-python-references-7.78.0.json b/references/posthog-python-references-7.78.0.json
new file mode 100644
index 000000000..66be86ee2
--- /dev/null
+++ b/references/posthog-python-references-7.78.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.78.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 70871253b..66be86ee2 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.77.0",
+    "version": "7.78.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 7083998df0c26079e748f9279f92ca764ceb19ea Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 13:23:58 -0400
Subject: [PATCH 125/245] chore(deps): bump the github-actions group with 3
 updates (#1128)

Bumps the github-actions group with 3 updates: [github/codeql-action/init](https://github.com/github/codeql-action), [github/codeql-action/analyze](https://github.com/github/codeql-action) and [PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml](https://github.com/posthog/posthog-sdk-test-harness).


Updates `github/codeql-action/init` from 4.38.3 to 4.39.0
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/24c54180a607b1449ed407dd24f251e4e9147c8d...6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee)

Updates `github/codeql-action/analyze` from 4.38.3 to 4.39.0
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/24c54180a607b1449ed407dd24f251e4e9147c8d...6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee)

Updates `PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml` from 1.15.0 to 1.17.0
- [Release notes](https://github.com/posthog/posthog-sdk-test-harness/releases)
- [Changelog](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/CHANGELOG.md)
- [Commits](https://github.com/posthog/posthog-sdk-test-harness/compare/64ffa6ab19166541880c077d349abe18a7e42395...8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3)

---
updated-dependencies:
- dependency-name: github/codeql-action/init
  dependency-version: 4.39.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.39.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml
  dependency-version: 1.17.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql.yml         | 4 ++--
 .github/workflows/sdk-compliance.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index fcaca264b..ea90e4ce8 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -40,6 +40,6 @@ jobs:
           trap-caching: false
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
         with:
           category: '/language:${{matrix.language}}'
diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index 0e4bfbe77..b200a0dc1 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -29,7 +29,7 @@ jobs:
 
   compliance:
     name: PostHog SDK compliance tests (capture v0)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@64ffa6ab19166541880c077d349abe18a7e42395 # 1.15.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3 # 1.17.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
@@ -39,7 +39,7 @@ jobs:
 
   compliance-v1:
     name: PostHog SDK compliance tests (capture v1)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@64ffa6ab19166541880c077d349abe18a7e42395 # 1.15.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3 # 1.17.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."

From bb2b9d6bddd250f6dcf03be565af8ba94694e5db Mon Sep 17 00:00:00 2001
From: "Gustavo H. Strassburger" <gustavo@posthog.com>
Date: Wed, 28 Oct 2026 18:20:17 -0300
Subject: [PATCH 126/245] feat: report unresolved local flags on evaluate_flags
 snapshots (#1133)

* feat: report unresolved local flags on evaluate_flags snapshots

Implements the "Snapshot unresolved flag reporting" and "Warning for flags local evaluation never resolves" requirements of the evaluate-flags spec (PostHog/sdk-specs#85).

- Add `FeatureFlagEvaluations.unresolved_flags`, with an `UnresolvedFlagReason` for each flag and the spec's fixed precedence.
- Report `local_evaluation_inconclusive` instead of `flag_missing` when a snapshot read hits an unresolved flag.
- Do not stop a condition at the first inconclusive filter, so a filter that does not match resolves the condition locally.
- Check `active` before experience continuity, also for dependencies.
- Log one warning per flag that local evaluation can never resolve, repeated only when its definition changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: 39793b31-809e-4689-a5d8-b4359cbb22c1

* fix: address review findings for unresolved local flags

* test(flags): check flag warnings run outside the publication lock

* fix(flags): fall back to the server when a flag dependency needs server data

* fix(flags): keep server fallback when the definition reason lookup fails
---
 .sampo/changesets/unresolved-local-flags.md |  13 +
 posthog/__init__.py                         |   4 +-
 posthog/async_client.py                     |   2 +
 posthog/client.py                           | 157 ++++-
 posthog/feature_flag_evaluations.py         |  32 +-
 posthog/feature_flags.py                    | 673 ++++++++++++++-----
 posthog/test/test_evaluate_flags.py         | 699 ++++++++++++++++++++
 posthog/test/test_feature_flags.py          | 552 +++++++++++++++-
 posthog/types.py                            |  29 +
 references/public_api_snapshot.txt          |  19 +-
 10 files changed, 1997 insertions(+), 183 deletions(-)
 create mode 100644 .sampo/changesets/unresolved-local-flags.md

diff --git a/.sampo/changesets/unresolved-local-flags.md b/.sampo/changesets/unresolved-local-flags.md
new file mode 100644
index 000000000..135465dc9
--- /dev/null
+++ b/.sampo/changesets/unresolved-local-flags.md
@@ -0,0 +1,13 @@
+---
+pypi/posthog: minor
+---
+
+Report flags that local evaluation could not resolve on `evaluate_flags()` snapshots. `FeatureFlagEvaluations.unresolved_flags` maps each such flag to an `UnresolvedFlagReason` (`experience_continuity`, `unsupported_definition`, `unresolved_dependency` or `missing_context`), and reading one reports the `local_evaluation_inconclusive` error instead of `flag_missing`. When definitions load, log one warning per flag that local evaluation can never resolve (experience continuity, a static cohort, an unknown operator, a malformed value, or a missing or circular flag dependency), and again only when its definition changes. `AsyncClient` evaluates only remotely, so its snapshots have no unresolved flags.
+
+Behavior changes:
+
+- A condition with a filter that local evaluation can't check and a filter that does not match now resolves locally as no match. Before, such a flag fell back to a remote request, or stayed unresolved with `only_evaluate_locally=True`.
+- An inactive flag with experience continuity enabled now resolves to `false` locally instead of falling back to a remote request.
+- A flag that depends on a flag with experience continuity enabled is no longer evaluated locally. It falls back to a remote request, or stays unresolved with `only_evaluate_locally=True`.
+- On `$feature_flag_called` events from an `evaluate_flags()` snapshot, `$feature_flag_error` is now `local_evaluation_inconclusive` instead of `flag_missing` for a flag that has a loaded definition but that local evaluation could not resolve.
+- `get_all_flags()`, `get_all_flags_and_payloads()` and `evaluate_flags()` no longer log an error with a traceback when a flag needs the server (for example, a static cohort). They fall back to a remote request without logging, as `get_feature_flag()` already did.
diff --git a/posthog/__init__.py b/posthog/__init__.py
index 2e870403c..a4c3f3678 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -83,6 +83,7 @@
     FeatureFlagEvaluationRuntime as FeatureFlagEvaluationRuntime,
     FlagValue as FlagValue,
     FlagsAndPayloads as FlagsAndPayloads,
+    UnresolvedFlagReason as UnresolvedFlagReason,
 )
 from posthog.types import (
     FeatureFlagResult as FeatureFlagResult,
@@ -1104,7 +1105,8 @@ def evaluate_flags(
         person_properties: Person properties to use for evaluation.
         group_properties: Group properties keyed by group type.
         only_evaluate_locally: If ``True``, never fall back to remote evaluation and
-            omit flags that cannot be evaluated locally.
+            omit flags that cannot be evaluated locally. The snapshot's
+            ``unresolved_flags`` lists them with a reason.
         disable_geoip: Whether to disable GeoIP lookup.
         flag_keys: Optional list that scopes local evaluation, the underlying ``/flags``
             request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 186bff727..d1015ebba 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -893,6 +893,8 @@ async def evaluate_flags(
 
         The returned snapshot has synchronous in-memory accessors. Pass it to
         ``capture(flags=...)`` to attach the exact values used for branching.
+        This client does not evaluate flags locally, so the snapshot's
+        ``unresolved_flags`` is always empty.
         """
         host = self._get_feature_flag_evaluations_host()
         if distinct_id is None:
diff --git a/posthog/client.py b/posthog/client.py
index bff6def5d..5d0a92ca4 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -11,7 +11,7 @@
 import weakref
 from contextvars import ContextVar
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict, List, Mapping, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union, cast
 from uuid import UUID, uuid4
 
 from typing_extensions import Unpack
@@ -77,6 +77,7 @@
 from posthog.feature_flags import (
     InconclusiveMatchError,
     RequiresServerEvaluation,
+    _get_definition_unresolved_reason,
     match_feature_flag_properties,
     resolve_bucketing_value,
 )
@@ -115,6 +116,7 @@
     FlagsResponse,
     FlagValue,
     SendFeatureFlagsOptions,
+    UnresolvedFlagReason,
     normalize_flags_response,
     to_flags_and_payloads,
     to_payloads,
@@ -926,6 +928,11 @@ def __init__(
         self._flag_definition_cache_generation = 0
         self._flag_definition_publication_lock = threading.RLock()
         self._flag_definition_cache_write_lock = threading.RLock()
+        # Flag key -> definition fingerprint of flags already warned about as never
+        # resolvable locally, so each warning fires once until the definition changes.
+        self._warned_unresolvable_flags: Dict[str, str] = {}
+        # Definitions fingerprint of the last scan for never-resolvable flags.
+        self._unresolvable_flags_fingerprint: Optional[str] = None
         self._flag_definition_cache_provider = flag_definition_cache_provider
         self._flag_definition_cache_provider_async_runner: Optional[
             _BackgroundEventLoopRunner
@@ -3262,6 +3269,101 @@ def _update_flag_state(
                 return old_fingerprint
         return None
 
+    def _warn_unresolvable_flags(self) -> None:
+        """Log flags the published definitions can never resolve locally.
+
+        Call it after publication, outside the publication lock: classifying every
+        flag walks its cohorts, and log handlers can be slow."""
+        with self._flag_definition_publication_lock:
+            definitions_fingerprint = self._flag_definition_fingerprint
+            if definitions_fingerprint == self._unresolvable_flags_fingerprint:
+                return
+            snapshot = self._local_evaluation_snapshot()
+
+        unresolvable = self._classify_unresolvable_flags(snapshot)
+
+        with self._flag_definition_publication_lock:
+            # Newer definitions or another caller own the warning for this state.
+            if (
+                definitions_fingerprint != self._flag_definition_fingerprint
+                or definitions_fingerprint == self._unresolvable_flags_fingerprint
+            ):
+                return
+            self._unresolvable_flags_fingerprint = definitions_fingerprint
+            new_keys_by_reason: Dict[UnresolvedFlagReason, List[str]] = {}
+            for key, (reason, fingerprint) in unresolvable.items():
+                if self._warned_unresolvable_flags.get(key) != fingerprint:
+                    new_keys_by_reason.setdefault(reason, []).append(key)
+            # Rebuilt from the current definitions, so a flag that is deleted or
+            # becomes resolvable is forgotten and warns again if it later becomes
+            # unresolvable.
+            self._warned_unresolvable_flags = {
+                key: fingerprint for key, (_, fingerprint) in unresolvable.items()
+            }
+
+        self._log_unresolvable_flags(new_keys_by_reason)
+
+    @staticmethod
+    def _classify_unresolvable_flags(
+        snapshot: _LocalEvaluationSnapshot,
+    ) -> Dict[str, Tuple[UnresolvedFlagReason, str]]:
+        """Map each never-resolvable flag key to its reason and a fingerprint of its
+        definition."""
+        unresolvable: Dict[str, Tuple[UnresolvedFlagReason, str]] = {}
+        for flag in snapshot["flags"]:
+            try:
+                key = flag["key"]
+                reason = _get_definition_unresolved_reason(
+                    flag,
+                    snapshot["flags_by_key"],
+                    snapshot["cohorts"],
+                    snapshot["group_type_mapping"],
+                )
+            except Exception:
+                # Evaluation reports a definition this malformed when the flag is used.
+                continue
+            if reason is None:
+                continue
+            fingerprint = _hashlib.sha256(
+                json.dumps([reason.value, flag], sort_keys=True, default=str).encode(
+                    "utf-8"
+                )
+            ).hexdigest()
+            unresolvable[str(key)] = (reason, fingerprint)
+        return unresolvable
+
+    def _log_unresolvable_flags(
+        self, new_keys_by_reason: Dict[UnresolvedFlagReason, List[str]]
+    ) -> None:
+        experience_continuity_keys = new_keys_by_reason.get(
+            UnresolvedFlagReason.EXPERIENCE_CONTINUITY
+        )
+        if experience_continuity_keys:
+            self.log.warning(
+                f"[FEATURE FLAGS] {len(experience_continuity_keys)} flag(s) have "
+                "experience continuity enabled and can't be evaluated locally "
+                f"(reason: {UnresolvedFlagReason.EXPERIENCE_CONTINUITY.value}): "
+                f"{', '.join(experience_continuity_keys)}. Evaluating them makes a "
+                "remote request, or leaves them unresolved with "
+                "only_evaluate_locally=True. To evaluate them locally, disable "
+                "experience continuity on these flags in PostHog."
+            )
+        unsupported_definition_keys = new_keys_by_reason.get(
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+        )
+        if unsupported_definition_keys:
+            self.log.warning(
+                f"[FEATURE FLAGS] {len(unsupported_definition_keys)} flag(s) use "
+                "something local evaluation doesn't support, such as a static "
+                "cohort, an unknown operator, a malformed value, or a missing or "
+                "circular flag dependency "
+                f"(reason: {UnresolvedFlagReason.UNSUPPORTED_DEFINITION.value}): "
+                f"{', '.join(unsupported_definition_keys)}. Evaluating them makes a "
+                "remote request when evaluation reaches that part, or leaves them "
+                "unresolved with only_evaluate_locally=True. To evaluate them "
+                "locally, change these flags in PostHog or upgrade posthog."
+            )
+
     def _local_evaluation_snapshot(self) -> _LocalEvaluationSnapshot:
         # Capture references together. Publication replaces these collections, so
         # recursive and multi-flag evaluations can finish on their original rules.
@@ -3301,6 +3403,7 @@ def _load_feature_flags(self):
                         "[FEATURE FLAGS] Using cached flag definitions from external cache"
                     )
                     old_fingerprint = self._update_flag_state(cached_data)
+                    self._warn_unresolvable_flags()
                     if isinstance(self.flag_cache, RedisFlagCache):
                         self.flag_cache._invalidate_snapshot(old_fingerprint)
                     self._last_feature_flag_poll = datetime.now(tz=timezone.utc)
@@ -3406,6 +3509,8 @@ def _fetch_feature_flags_from_api(self):
                 self._flag_definition_published_generation = fetch_generation
                 self._flag_definition_cache_generation = fetch_generation
 
+            self._warn_unresolvable_flags()
+
             if cache_data_to_store and self._flag_definition_cache_provider:
                 # Keep provider I/O out of the publication lock. The separate lock
                 # preserves cache write order without delaying newer API fetches or
@@ -3567,12 +3672,15 @@ def _compute_flag_locally(
         # Create evaluation cache for flag dependencies
         evaluation_cache: dict[str, Optional[FlagValue]] = {}
 
-        if feature_flag.get("ensure_experience_continuity", False):
-            raise InconclusiveMatchError("Flag has experience continuity enabled")
-
         if not feature_flag.get("active"):
             return False
 
+        if feature_flag.get("ensure_experience_continuity", False):
+            raise InconclusiveMatchError(
+                "Flag has experience continuity enabled",
+                reason=UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+            )
+
         flag_filters = feature_flag.get("filters") or {}
         aggregation_group_type_index = flag_filters.get("aggregation_group_type_index")
         group_type_mapping = snapshot["group_type_mapping"]
@@ -3585,7 +3693,10 @@ def _compute_flag_locally(
                     f"[FEATURE FLAGS] Unknown group type index {aggregation_group_type_index} for feature flag {feature_flag['key']}"
                 )
                 # failover to `/flags`
-                raise InconclusiveMatchError("Flag has unknown group type index")
+                raise InconclusiveMatchError(
+                    "Flag has unknown group type index",
+                    reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+                )
 
             if group_name not in groups:
                 # Group flags are never enabled in `groups` aren't passed in
@@ -3602,7 +3713,8 @@ def _compute_flag_locally(
 
             if group_name not in group_properties:
                 raise InconclusiveMatchError(
-                    f"Flag has no group properties for group '{group_name}'"
+                    f"Flag has no group properties for group '{group_name}'",
+                    reason=UnresolvedFlagReason.MISSING_CONTEXT,
                 )
             focused_group_properties = group_properties[group_name]
             group_key = groups[group_name]
@@ -3621,9 +3733,23 @@ def _compute_flag_locally(
                 group_properties=group_properties,
             )
         else:
-            bucketing_value = resolve_bucketing_value(
-                feature_flag, distinct_id, device_id
-            )
+            try:
+                bucketing_value = resolve_bucketing_value(
+                    feature_flag, distinct_id, device_id
+                )
+            except InconclusiveMatchError as e:
+                # No condition is checked without a bucketing value, so a cause in
+                # the definition also applies and outranks missing_context.
+                e.reason = (
+                    _get_definition_unresolved_reason(
+                        feature_flag,
+                        flags_by_key,
+                        snapshot["cohorts"],
+                        group_type_mapping,
+                    )
+                    or e.reason
+                )
+                raise
             return match_feature_flag_properties(
                 feature_flag,
                 distinct_id,
@@ -4539,7 +4665,8 @@ def evaluate_flags(
             person_properties: Person properties to use for evaluation.
             group_properties: Group properties keyed by group type.
             only_evaluate_locally: If True, never fall back to remote evaluation —
-                flags that can't be evaluated locally are simply omitted from the snapshot.
+                flags that can't be evaluated locally are omitted from the snapshot and
+                listed with a reason in its ``unresolved_flags``.
             disable_geoip: Whether to disable GeoIP lookup.
             flag_keys: Optional list that scopes local evaluation, the underlying
                 ``/flags`` request, and the returned snapshot. When omitted or ``None``, all
@@ -4610,6 +4737,7 @@ def evaluate_flags(
         errors_while_computing = False
         quota_limited = False
         locally_evaluated_keys: set[str] = set()
+        unresolved: Dict[str, UnresolvedFlagReason] = {}
         # Try local evaluation first when the poller has loaded definitions.
         local_person_properties = self._person_properties_for_local_evaluation(
             distinct_id, person_properties
@@ -4622,6 +4750,7 @@ def evaluate_flags(
                 group_properties=group_properties,
                 flag_keys_to_evaluate=flag_keys,
                 device_id=device_id,
+                unresolved=unresolved,
             )
         )
 
@@ -4732,6 +4861,9 @@ def evaluate_flags(
             errors_while_computing=errors_while_computing,
             quota_limited=quota_limited,
             minimal_flag_called_events=minimal_flag_called_events,
+            unresolved_flags={
+                key: reason for key, reason in unresolved.items() if key not in records
+            },
         )
 
     _feature_flag_evaluations_host_cache: Optional[_FeatureFlagEvaluationsHost] = None
@@ -4754,6 +4886,7 @@ def _get_all_flags_and_payloads_locally(
         warn_on_unknown_groups=False,
         flag_keys_to_evaluate: Optional[list[str]] = None,
         device_id: Optional[str] = None,
+        unresolved: Optional[Dict[str, UnresolvedFlagReason]] = None,
     ) -> tuple[FlagsAndPayloads, bool, _LocalEvaluationSnapshot]:
         person_properties = person_properties or {}
         group_properties = group_properties or {}
@@ -4794,9 +4927,11 @@ def _get_all_flags_and_payloads_locally(
                     )
                     if matched_payload is not None:
                         payloads[flag["key"]] = matched_payload
-                except InconclusiveMatchError:
+                except (InconclusiveMatchError, RequiresServerEvaluation) as e:
                     # No need to log this, since it's just telling us to fall back to `/flags`
                     fallback_to_flags = True
+                    if unresolved is not None:
+                        unresolved[flag["key"]] = e.reason
                 except Exception as e:
                     self.log.exception(
                         f"[FEATURE FLAGS] Error while computing variant and payload: {e}"
diff --git a/posthog/feature_flag_evaluations.py b/posthog/feature_flag_evaluations.py
index c260fbde7..13d8c7df9 100644
--- a/posthog/feature_flag_evaluations.py
+++ b/posthog/feature_flag_evaluations.py
@@ -6,9 +6,10 @@
 """
 
 from dataclasses import dataclass
+from types import MappingProxyType
 from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Union
 
-from posthog.types import FlagValue
+from posthog.types import FlagValue, UnresolvedFlagReason
 
 
 @dataclass(frozen=True)
@@ -73,6 +74,7 @@ def __init__(
         quota_limited: bool = False,
         minimal_flag_called_events: bool = False,
         accessed: Optional[Set[str]] = None,
+        unresolved_flags: Optional[Mapping[str, UnresolvedFlagReason]] = None,
     ) -> None:
         """Internal — instances are created by the SDK via ``Client.evaluate_flags()``."""
         self._host = host
@@ -89,6 +91,9 @@ def __init__(
         # server response, not whatever the client-wide gate happens to be at send time.
         self._minimal_flag_called_events = minimal_flag_called_events
         self._accessed: Set[str] = set(accessed) if accessed is not None else set()
+        self._unresolved_flags: Dict[str, UnresolvedFlagReason] = dict(
+            unresolved_flags or {}
+        )
 
     def is_enabled(self, key: str, default_value: bool = False) -> bool:
         """Return whether the flag is enabled. Fires ``$feature_flag_called`` on the
@@ -165,6 +170,22 @@ def keys(self) -> List[str]:
         """Return the flag keys that are part of this evaluation."""
         return list(self._flags.keys())
 
+    @property
+    def unresolved_flags(self) -> Mapping[str, UnresolvedFlagReason]:
+        """Return a read-only mapping of flag key to the reason local evaluation
+        left it without a value.
+
+        A flag is listed when it has a loaded local definition, was in the requested
+        scope, was inconclusive locally, and no remote value filled the gap. Listed
+        flags are not part of :attr:`keys`, and reading one reports the
+        ``local_evaluation_inconclusive`` error instead of ``flag_missing``. Reading
+        this mapping does not count as an access and does not fire any event.
+        Snapshots returned by :meth:`only` and :meth:`only_accessed`, and by
+        ``AsyncClient.evaluate_flags()``, which evaluates only remotely, carry no
+        entries.
+        """
+        return MappingProxyType(self._unresolved_flags)
+
     # --- Internal -------------------------------------------------------------
 
     def _get_event_properties(self) -> Dict[str, Any]:
@@ -256,14 +277,19 @@ def _record_access(self, key: str) -> None:
 
         # Build the comma-joined `$feature_flag_error` matching the single-flag path's
         # granularity: response-level errors (errors-while-computing, quota-limited) are
-        # combined with per-flag errors (flag-missing) so consumers can filter by type.
+        # combined with per-flag errors (flag-missing or local-evaluation-inconclusive)
+        # so consumers can filter by type.
         errors: List[str] = []
         if self._errors_while_computing:
             errors.append("errors_while_computing_flags")
         if self._quota_limited:
             errors.append("quota_limited")
         if flag is None:
-            errors.append("flag_missing")
+            errors.append(
+                "local_evaluation_inconclusive"
+                if key in self._unresolved_flags
+                else "flag_missing"
+            )
         if errors:
             properties["$feature_flag_error"] = ",".join(errors)
 
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index 66af600c7..e0ffda658 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -12,7 +12,7 @@
 from typing import NamedTuple, NoReturn, Optional
 
 from posthog import utils as utils
-from posthog.types import FlagValue
+from posthog.types import FlagValue, UnresolvedFlagReason
 from posthog.utils import convert_to_datetime_aware
 from posthog.utils import is_valid_regex as is_valid_regex
 
@@ -96,19 +96,52 @@ class ConditionMatch(Enum):
 
 
 class InconclusiveMatchError(Exception):
-    pass
+    """
+    Raised when local evaluation can't determine a flag's value. ``reason`` says
+    why, as reported by ``FeatureFlagEvaluations.unresolved_flags``.
+    """
+
+    reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+
+    def __init__(self, *args, reason: Optional[UnresolvedFlagReason] = None):
+        super().__init__(*args)
+        if reason is not None:
+            self.reason = reason
 
 
 class RequiresServerEvaluation(Exception):
     """
     Raised when feature flag evaluation requires server-side data that is not
-    available locally (e.g., static cohorts, experience continuity).
+    available locally (e.g., static cohorts).
 
     This error should propagate immediately to trigger API fallback, unlike
     InconclusiveMatchError which allows trying other conditions.
     """
 
-    pass
+    reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+
+    def __init__(self, *args, reason: Optional[UnresolvedFlagReason] = None):
+        super().__init__(*args)
+        if reason is not None:
+            self.reason = reason
+
+
+# When several causes apply to one flag, the spec reports the first reason in this
+# order, so every SDK picks the same reason whatever order it inspects filters in.
+_UNRESOLVED_REASON_PRECEDENCE = (
+    UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+    UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+    UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+    UnresolvedFlagReason.MISSING_CONTEXT,
+)
+
+
+def _pick_unresolved_reason(
+    current: Optional[UnresolvedFlagReason], new: UnresolvedFlagReason
+) -> UnresolvedFlagReason:
+    if current is None:
+        return new
+    return min(current, new, key=_UNRESOLVED_REASON_PRECEDENCE.index)
 
 
 # This function takes a bucketing value and a feature flag key and returns a float between 0 and 1.
@@ -180,6 +213,20 @@ def variant_lookup_table(feature_flag):
     return lookup_table
 
 
+def _flag_dependency_shape_problem(prop) -> Optional[str]:
+    """Describe why a flag dependency condition is malformed, or return None.
+
+    Shared by local evaluation and the load-time classifier, so the two agree."""
+    operator = prop.get("operator", "exact")
+    if operator != "flag_evaluates_to":
+        return f"invalid operator '{operator}'"
+    # Test `is None`, not truthiness: `False` is a valid expected value (the case
+    # flag dependencies exist for).
+    if not prop.get("key") or prop.get("value") is None:
+        return "missing key or value"
+    return None
+
+
 def evaluate_flag_dependency(
     property,
     flags_by_key,
@@ -222,40 +269,62 @@ def evaluate_flag_dependency(
     if flags_by_key is None or evaluation_cache is None:
         # Cannot evaluate flag dependencies without required context
         raise InconclusiveMatchError(
-            f"Cannot evaluate flag dependency on '{property.get('key', 'unknown')}' without flags_by_key and evaluation_cache"
+            f"Cannot evaluate flag dependency on '{property.get('key', 'unknown')}' without flags_by_key and evaluation_cache",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
         )
 
     # Validate the condition shape before walking the chain. A malformed shape
     # is a definitive no-match (return False), mirroring the server-side Rust
     # evaluator (match_flag_value_to_flag_filter). Raising InconclusiveMatchError
     # here would force a billable /flags network fallback on every evaluation of
-    # the affected flag. Test `is None`, not truthiness: `False` is a valid
-    # expected value (the case flag dependencies exist for).
+    # the affected flag.
     flag_key = property.get("key")
     expected_value = property.get("value")
-    operator = property.get("operator", "exact")
 
-    if operator != "flag_evaluates_to":
-        _warn_malformed_flag_dependency_once(flag_key, f"invalid operator '{operator}'")
-        return False
-    if not flag_key or expected_value is None:
-        _warn_malformed_flag_dependency_once(flag_key, "missing key or value")
+    shape_problem = _flag_dependency_shape_problem(property)
+    if shape_problem is not None:
+        _warn_malformed_flag_dependency_once(flag_key, shape_problem)
         return False
 
     # Check if dependency_chain is present - it should always be provided for flag dependencies
     if "dependency_chain" not in property:
         # Missing dependency_chain indicates malformed server data
         raise InconclusiveMatchError(
-            f"Flag dependency property for '{property.get('key', 'unknown')}' is missing required 'dependency_chain' field"
+            f"Flag dependency property for '{property.get('key', 'unknown')}' is missing required 'dependency_chain' field",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
         )
 
     dependency_chain = property["dependency_chain"]
 
+    if not isinstance(dependency_chain, list):
+        raise InconclusiveMatchError(
+            f"Flag dependency property for '{flag_key}' has an invalid 'dependency_chain' field",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+
     # Handle circular dependency (empty chain means circular)
     if len(dependency_chain) == 0:
         log.debug(f"Circular dependency detected for flag: {property.get('key')}")
         raise InconclusiveMatchError(
-            f"Circular dependency detected for flag '{property.get('key', 'unknown')}'"
+            f"Circular dependency detected for flag '{property.get('key', 'unknown')}'",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+
+    # A dependency with no definition outranks one that is only inconclusive, so
+    # check the whole chain before evaluating any of it.
+    missing_dependency = next(
+        (
+            key
+            for key in dependency_chain
+            if key not in evaluation_cache and not flags_by_key.get(key)
+        ),
+        None,
+    )
+    if missing_dependency is not None:
+        evaluation_cache[missing_dependency] = None
+        raise InconclusiveMatchError(
+            f"Cannot evaluate flag dependency '{missing_dependency}' - flag not found in local flags",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
         )
 
     # Evaluate and cache each flag in the chain; members already cached are
@@ -264,19 +333,21 @@ def evaluate_flag_dependency(
         if dep_flag_key in evaluation_cache:
             continue
 
-        dep_flag = flags_by_key.get(dep_flag_key)
-        if not dep_flag:
-            # Missing flag dependency - cannot evaluate locally
-            evaluation_cache[dep_flag_key] = None
-            raise InconclusiveMatchError(
-                f"Cannot evaluate flag dependency '{dep_flag_key}' - flag not found in local flags"
-            )
+        dep_flag = flags_by_key[dep_flag_key]
 
-        # Check if the flag is active (same check as in client._compute_flag_locally)
+        # Same order as client._compute_flag_locally: an inactive flag is false
+        # whatever its experience continuity setting.
         if not dep_flag.get("active"):
             evaluation_cache[dep_flag_key] = False
             continue
 
+        if dep_flag.get("ensure_experience_continuity"):
+            evaluation_cache[dep_flag_key] = None
+            raise InconclusiveMatchError(
+                f"Cannot evaluate flag dependency '{dep_flag_key}' - flag has experience continuity enabled",
+                reason=UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            )
+
         # Recursively evaluate the dependency
         try:
             dep_flag_filters = dep_flag.get("filters") or {}
@@ -303,11 +374,20 @@ def evaluate_flag_dependency(
                 bucketing_value=dep_bucketing_value,
             )
             evaluation_cache[dep_flag_key] = dep_result
+        except RequiresServerEvaluation as e:
+            # The dependent flag needs the server too, so its later conditions must
+            # not resolve it locally. Nothing is cached, so another filter on this
+            # dependency also raises this error.
+            raise RequiresServerEvaluation(
+                f"Cannot evaluate flag dependency '{dep_flag_key}': {e}",
+                reason=UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            ) from e
         except InconclusiveMatchError as e:
             # If we can't evaluate a dependency, store None and propagate the error
             evaluation_cache[dep_flag_key] = None
             raise InconclusiveMatchError(
-                f"Cannot evaluate flag dependency '{dep_flag_key}': {e}"
+                f"Cannot evaluate flag dependency '{dep_flag_key}': {e}",
+                reason=UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
             ) from e
 
     # The condition matches iff the referenced flag's value matches the expected
@@ -315,8 +395,16 @@ def evaluate_flag_dependency(
     # definitive False, which must be allowed to match `expected_value=False`.
     actual_value = evaluation_cache.get(flag_key)
     if actual_value is None:
+        # A referenced flag that has no loaded definition or is missing from the
+        # chain is a definition problem, not an unresolved dependency.
+        reason = (
+            UnresolvedFlagReason.UNRESOLVED_DEPENDENCY
+            if flag_key in flags_by_key and flag_key in evaluation_cache
+            else UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+        )
         raise InconclusiveMatchError(
-            f"Flag dependency '{flag_key}' was inconclusive or not evaluated"
+            f"Flag dependency '{flag_key}' was inconclusive or not evaluated",
+            reason=reason,
         )
     return matches_dependency_value(expected_value, actual_value)
 
@@ -371,7 +459,8 @@ def resolve_bucketing_value(flag, distinct_id, device_id=None):
     if bucketing_identifier == "device_id":
         if not device_id:
             raise InconclusiveMatchError(
-                "Flag requires device_id for bucketing but none was provided"
+                "Flag requires device_id for bucketing but none was provided",
+                reason=UnresolvedFlagReason.MISSING_CONTEXT,
             )
         return device_id
     return distinct_id
@@ -412,7 +501,7 @@ def match_feature_flag_properties(
     flag_conditions = flag_filters.get("groups") or []
     flag_aggregation = flag_filters.get("aggregation_group_type_index")
     early_exit_enabled = flag_filters.get("early_exit")
-    is_inconclusive = False
+    inconclusive_reason: Optional[UnresolvedFlagReason] = None
     cohort_properties = cohort_properties or {}
     groups = groups or {}
     group_properties = group_properties or {}
@@ -443,7 +532,9 @@ def match_feature_flag_properties(
                         )
                         continue
                     if group_name not in group_properties:
-                        is_inconclusive = True
+                        inconclusive_reason = _pick_unresolved_reason(
+                            inconclusive_reason, UnresolvedFlagReason.MISSING_CONTEXT
+                        )
                         continue
                     effective_properties = group_properties[group_name]
                     effective_bucketing = groups[group_name]
@@ -480,20 +571,32 @@ def match_feature_flag_properties(
                 # The condition's property filters (if any) matched and only the rollout check
                 # failed, so re-evaluating later groups can't change the outcome. If an earlier
                 # condition was inconclusive, stop here but preserve that result for fallback.
-                if is_inconclusive:
+                if inconclusive_reason is not None:
                     break
                 return False
-        except RequiresServerEvaluation:
-            # Static cohort or other missing server-side data - must fallback to API
+        except RequiresServerEvaluation as e:
+            # Static cohort or other missing server-side data - must fallback to API.
+            # The loop stops here, so a filter it did not reach can still carry a
+            # higher-precedence reason in the flag's definition.
+            try:
+                definition_reason = _get_definition_unresolved_reason(
+                    flag, flags_by_key or {}, cohort_properties, group_type_mapping
+                )
+            except Exception:
+                # A malformed definition must not stop the fallback to the server.
+                definition_reason = None
+            if definition_reason is not None:
+                e.reason = _pick_unresolved_reason(e.reason, definition_reason)
             raise
-        except InconclusiveMatchError:
+        except InconclusiveMatchError as e:
             # Evaluation error (bad regex, invalid date, missing property, etc.)
             # Track that we had an inconclusive match, but try other conditions
-            is_inconclusive = True
+            inconclusive_reason = _pick_unresolved_reason(inconclusive_reason, e.reason)
 
-    if is_inconclusive:
+    if inconclusive_reason is not None:
         raise InconclusiveMatchError(
-            "Can't determine if feature flag is enabled or not with given properties"
+            "Can't determine if feature flag is enabled or not with given properties",
+            reason=inconclusive_reason,
         )
 
     # We can only return False when either all conditions are False, or
@@ -501,6 +604,43 @@ def match_feature_flag_properties(
     return False
 
 
+def _match_condition_filter(
+    prop,
+    properties,
+    cohort_properties,
+    flags_by_key,
+    evaluation_cache,
+    distinct_id,
+    *,
+    device_id,
+    property_matching_version: int,
+) -> bool:
+    property_type = prop.get("type")
+    if property_type == "cohort":
+        return match_cohort(
+            prop,
+            properties,
+            cohort_properties,
+            flags_by_key,
+            evaluation_cache,
+            distinct_id,
+            device_id=device_id,
+            property_matching_version=property_matching_version,
+        )
+    if property_type == "flag":
+        return evaluate_flag_dependency(
+            prop,
+            flags_by_key,
+            evaluation_cache,
+            distinct_id,
+            properties,
+            cohort_properties,
+            device_id=device_id,
+            property_matching_version=property_matching_version,
+        )
+    return match_property(prop, properties, property_matching_version)
+
+
 def is_condition_match(
     feature_flag,
     distinct_id,
@@ -516,10 +656,14 @@ def is_condition_match(
 ) -> ConditionMatch:
     rollout_percentage = condition.get("rollout_percentage")
     if len(condition.get("properties") or []) > 0:
+        # Filters in a condition have no defined order, so an inconclusive filter does
+        # not stop the loop: a later filter can still rule the condition out or carry a
+        # higher-precedence reason.
+        inconclusive_reason: Optional[UnresolvedFlagReason] = None
+        server_evaluation_error: Optional[RequiresServerEvaluation] = None
         for prop in condition.get("properties"):
-            property_type = prop.get("type")
-            if property_type == "cohort":
-                matches = match_cohort(
+            try:
+                matches = _match_condition_filter(
                     prop,
                     properties,
                     cohort_properties,
@@ -529,22 +673,41 @@ def is_condition_match(
                     device_id=device_id,
                     property_matching_version=property_matching_version,
                 )
-            elif property_type == "flag":
-                matches = evaluate_flag_dependency(
-                    prop,
-                    flags_by_key,
-                    evaluation_cache,
-                    distinct_id,
-                    properties,
-                    cohort_properties,
-                    device_id=device_id,
-                    property_matching_version=property_matching_version,
+            except RequiresServerEvaluation as e:
+                # Fall back to the server only when this is the first filter that could
+                # not be checked, as when the loop stopped there. After another
+                # inconclusive filter, later conditions must still be able to resolve
+                # the flag locally.
+                if inconclusive_reason is None:
+                    server_evaluation_error = e
+                inconclusive_reason = _pick_unresolved_reason(
+                    inconclusive_reason, e.reason
                 )
-            else:
-                matches = match_property(prop, properties, property_matching_version)
+                continue
+            except InconclusiveMatchError as e:
+                inconclusive_reason = _pick_unresolved_reason(
+                    inconclusive_reason, e.reason
+                )
+                continue
+            except Exception:
+                # After an inconclusive filter, an unexpected error ends the condition
+                # as inconclusive, so later conditions can still resolve the flag.
+                if inconclusive_reason is None:
+                    raise
+                break
             if not matches:
                 return ConditionMatch.NO_MATCH
 
+        # Re-raise the original error type: match_feature_flag_properties stops at it
+        # and falls back to the server instead of trying later conditions.
+        if server_evaluation_error is not None:
+            raise server_evaluation_error
+        if inconclusive_reason is not None:
+            raise InconclusiveMatchError(
+                f"Can't determine if a condition of flag {feature_flag.get('key')} matches",
+                reason=inconclusive_reason,
+            )
+
         if rollout_percentage is None:
             return ConditionMatch.MATCH
 
@@ -567,10 +730,14 @@ def is_condition_match(
 )
 
 
-def _format_json_float(value: float) -> str:
+# The value helpers below convert both filter values and values from the evaluation
+# call. ``reason`` names the owner of the value: UNSUPPORTED_DEFINITION for a filter
+# value, MISSING_CONTEXT for a value the call passed.
+def _format_json_float(value: float, reason: UnresolvedFlagReason) -> str:
     if not math.isfinite(value):
         raise InconclusiveMatchError(
-            "Non-finite property values cannot be represented by the flags service"
+            "Non-finite property values cannot be represented by the flags service",
+            reason=reason,
         )
 
     representation = repr(value)
@@ -586,7 +753,7 @@ def _format_json_float(value: float) -> str:
     return f"{mantissa}e{sign}{exponent}"
 
 
-def _json_value_to_string(value) -> str:
+def _json_value_to_string(value, reason: UnresolvedFlagReason) -> str:
     if value is None:
         return "null"
     if isinstance(value, bool):
@@ -596,33 +763,37 @@ def _json_value_to_string(value) -> str:
     if isinstance(value, int):
         return str(value)
     if isinstance(value, float):
-        return _format_json_float(value)
+        return _format_json_float(value, reason)
     if isinstance(value, list):
-        return "[" + ",".join(_json_value_to_string(item) for item in value) + "]"
+        return (
+            "[" + ",".join(_json_value_to_string(item, reason) for item in value) + "]"
+        )
     if isinstance(value, dict):
         if not all(isinstance(key, str) for key in value):
             raise InconclusiveMatchError(
-                "Property object keys must be strings for local evaluation"
+                "Property object keys must be strings for local evaluation",
+                reason=reason,
             )
         items = (
-            f"{json.dumps(key, ensure_ascii=False)}:{_json_value_to_string(value[key])}"
+            f"{json.dumps(key, ensure_ascii=False)}:{_json_value_to_string(value[key], reason)}"
             for key in sorted(value)
         )
         return "{" + ",".join(items) + "}"
 
     raise InconclusiveMatchError(
-        f"Property value of type {type(value).__name__} is not JSON-compatible"
+        f"Property value of type {type(value).__name__} is not JSON-compatible",
+        reason=reason,
     )
 
 
-def _value_to_string(value) -> str:
+def _value_to_string(value, reason: UnresolvedFlagReason) -> str:
     if isinstance(value, str):
         return value
-    return _json_value_to_string(value)
+    return _json_value_to_string(value, reason)
 
 
-def _ascii_lower(value) -> str:
-    return _value_to_string(value).translate(_ASCII_LOWER_TRANSLATION)
+def _ascii_lower(value, reason: UnresolvedFlagReason) -> str:
+    return _value_to_string(value, reason).translate(_ASCII_LOWER_TRANSLATION)
 
 
 def _is_truthy_or_falsy_property_value(value) -> bool:
@@ -686,7 +857,10 @@ def _compile_regex(pattern: str) -> Optional[_RegexMetadata]:
     index = 0
 
     def defer() -> NoReturn:
-        raise InconclusiveMatchError("Regex requires server evaluation")
+        raise InconclusiveMatchError(
+            "Regex requires server evaluation",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
 
     while index < len(pattern):
         character = pattern[index]
@@ -824,7 +998,8 @@ def defer() -> NoReturn:
         return None
     except Exception as error:
         raise InconclusiveMatchError(
-            "Regex compilation requires server evaluation"
+            "Regex compilation requires server evaluation",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
         ) from error
 
     return _RegexMetadata(
@@ -852,7 +1027,10 @@ def _match_regex(pattern: str, value: str) -> Optional[bool]:
     ) = metadata
 
     def defer() -> NoReturn:
-        raise InconclusiveMatchError("Regex requires server evaluation")
+        raise InconclusiveMatchError(
+            "Regex requires server evaluation",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
 
     # Tightening $ can expose backtracking on a final LF, including repeated alternatives.
     if uses_end_anchor and uses_quantifier_or_alternation and value.endswith("\n"):
@@ -873,12 +1051,122 @@ def defer() -> NoReturn:
         return regex.search(value) is not None
     except Exception as error:
         raise InconclusiveMatchError(
-            "Regex execution requires server evaluation"
+            "Regex execution requires server evaluation",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
         ) from error
 
 
+_TEXT_OPERATORS = (
+    "icontains",
+    "not_icontains",
+    "starts_with",
+    "not_starts_with",
+    "ends_with",
+    "not_ends_with",
+)
+
+
+def _parse_numeric_filter(value) -> float:
+    parsed_value = _parse_numeric_value(value)
+    if parsed_value is None:
+        raise InconclusiveMatchError(
+            "The numeric condition is not a finite number",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+    return parsed_value
+
+
+def _parse_date_filter(value) -> datetime.datetime:
+    try:
+        parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
+
+        if not parsed_date:
+            parsed_date = parse_datetime(str(value))
+            parsed_date = convert_to_datetime_aware(parsed_date)
+    except Exception as e:
+        raise InconclusiveMatchError(
+            "The date set on the flag is not a valid format",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        ) from e
+
+    if not parsed_date:
+        raise InconclusiveMatchError(
+            "The date set on the flag is not a valid format",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+    return parsed_date
+
+
+@_lru_cache(maxsize=1024)
+def _assert_date_filter_supported(value: str) -> None:
+    """Cache only valid filter values; lru_cache does not keep exceptions. Matching
+    still parses each time, so relative dates resolve against the current time."""
+    _parse_date_filter(value)
+
+
+def _parse_semver_filter(operator, value) -> tuple:
+    """Return the parsed version for a comparison operator, or the (lower, upper)
+    bounds for a range operator."""
+    try:
+        if operator == "semver_tilde":
+            return _tilde_bounds(str(value))
+        if operator == "semver_caret":
+            return _caret_bounds(str(value))
+        if operator == "semver_wildcard":
+            return _wildcard_bounds(str(value))
+        return parse_semver(value)
+    except (ValueError, TypeError):
+        raise InconclusiveMatchError(
+            f"Flag semver value '{value}' is not valid for operator {operator}",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+
+
+def _assert_filter_supported(property) -> None:
+    """Raise an unsupported_definition error when local evaluation can't use a
+    property filter, whatever the call passes: an unknown operator, or a filter
+    value the operator can't parse."""
+    operator = property.get("operator") or "exact"
+    value = property.get("value")
+    if operator not in PROPERTY_OPERATORS:
+        raise InconclusiveMatchError(
+            f"Unknown operator {operator}",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+    if operator in ("exact", "is_not"):
+        for item in value if isinstance(value, list) else [value]:
+            _value_to_string(item, UnresolvedFlagReason.UNSUPPORTED_DEFINITION)
+    elif operator in _TEXT_OPERATORS:
+        _value_to_string(value, UnresolvedFlagReason.UNSUPPORTED_DEFINITION)
+    elif operator in ("regex", "not_regex"):
+        pattern = str(value)
+        if pattern:
+            _compile_regex(pattern)
+    elif operator in NUMERIC_OPERATORS:
+        _parse_numeric_filter(value)
+    elif operator in DATE_OPERATORS:
+        _assert_date_filter_supported(str(value))
+    elif operator in SEMVER_OPERATORS:
+        _parse_semver_filter(operator, value)
+
+
 def match_property(
     property, property_values, property_matching_version: int = 1
+) -> bool:
+    try:
+        return _match_property_value(
+            property, property_values, property_matching_version
+        )
+    except InconclusiveMatchError as e:
+        # An unusable filter outranks missing context, so check the filter before
+        # blaming the context.
+        if e.reason == UnresolvedFlagReason.MISSING_CONTEXT:
+            _assert_filter_supported(property)
+        raise
+
+
+def _match_property_value(
+    property, property_values, property_matching_version: int
 ) -> bool:
     # only looks for matches where key exists in override_property_values
     key = property.get("key")
@@ -886,11 +1174,15 @@ def match_property(
     value = property.get("value")
 
     if operator not in PROPERTY_OPERATORS:
-        raise InconclusiveMatchError(f"Unknown operator {operator}")
+        raise InconclusiveMatchError(
+            f"Unknown operator {operator}",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
 
     if key not in property_values:
         raise InconclusiveMatchError(
-            "can't match properties without a given property value"
+            "can't match properties without a given property value",
+            reason=UnresolvedFlagReason.MISSING_CONTEXT,
         )
 
     if operator in ("is_set", "is_not_set"):
@@ -899,9 +1191,7 @@ def match_property(
     override_value = property_values[key]
 
     if operator in NUMERIC_OPERATORS:
-        parsed_value = _parse_numeric_value(value)
-        if parsed_value is None:
-            raise InconclusiveMatchError("The numeric condition is not a finite number")
+        parsed_value = _parse_numeric_filter(value)
         parsed_override = _parse_numeric_value(override_value)
         if parsed_override is None:
             return False
@@ -924,7 +1214,9 @@ def match_property(
     if operator in ("exact", "is_not"):
 
         def compute_exact_match(value, override_value):
-            override_string = _value_to_string(override_value).lower()
+            override_string = _value_to_string(
+                override_value, UnresolvedFlagReason.MISSING_CONTEXT
+            ).lower()
             # Empty filters retain recursive truthiness in both matching modes.
             if value == []:
                 return _is_truthy_property_value(override_value)
@@ -937,25 +1229,28 @@ def compute_exact_match(value, override_value):
 
             if isinstance(value, list):
                 return override_string in [
-                    _value_to_string(candidate).lower() for candidate in value
+                    _value_to_string(
+                        candidate, UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+                    ).lower()
+                    for candidate in value
                 ]
-            return _value_to_string(value).lower() == override_string
+            return (
+                _value_to_string(
+                    value, UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+                ).lower()
+                == override_string
+            )
 
         if operator == "exact":
             return compute_exact_match(value, override_value)
         else:
             return not compute_exact_match(value, override_value)
 
-    if operator in (
-        "icontains",
-        "not_icontains",
-        "starts_with",
-        "not_starts_with",
-        "ends_with",
-        "not_ends_with",
-    ):
-        property_string = _ascii_lower(override_value)
-        filter_string = _ascii_lower(value)
+    if operator in _TEXT_OPERATORS:
+        property_string = _ascii_lower(
+            override_value, UnresolvedFlagReason.MISSING_CONTEXT
+        )
+        filter_string = _ascii_lower(value, UnresolvedFlagReason.UNSUPPORTED_DEFINITION)
 
         if operator in ("icontains", "not_icontains"):
             matched = filter_string in property_string
@@ -975,22 +1270,8 @@ def compute_exact_match(value, override_value):
             return False
         return not regex_match if operator == "not_regex" else regex_match
 
-    if operator in ["is_date_before", "is_date_after"]:
-        try:
-            parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
-
-            if not parsed_date:
-                parsed_date = parse_datetime(str(value))
-                parsed_date = convert_to_datetime_aware(parsed_date)
-        except Exception as e:
-            raise InconclusiveMatchError(
-                "The date set on the flag is not a valid format"
-            ) from e
-
-        if not parsed_date:
-            raise InconclusiveMatchError(
-                "The date set on the flag is not a valid format"
-            )
+    if operator in DATE_OPERATORS:
+        parsed_date = _parse_date_filter(value)
 
         if isinstance(override_value, datetime.datetime):
             override_date = convert_to_datetime_aware(override_value)
@@ -1012,71 +1293,51 @@ def compute_exact_match(value, override_value):
                 else:
                     return override_date > parsed_date
             except Exception:
-                raise InconclusiveMatchError("The date provided is not a valid format")
+                raise InconclusiveMatchError(
+                    "The date provided is not a valid format",
+                    reason=UnresolvedFlagReason.MISSING_CONTEXT,
+                )
         else:
             raise InconclusiveMatchError(
-                "The date provided must be a string or date object"
+                "The date provided must be a string or date object",
+                reason=UnresolvedFlagReason.MISSING_CONTEXT,
             )
 
     if operator in SEMVER_OPERATORS:
+        flag_semver = _parse_semver_filter(operator, value)
         try:
             override_parsed = parse_semver(override_value)
         except (ValueError, TypeError):
             raise InconclusiveMatchError(
-                f"Person property value '{override_value}' is not a valid semver"
+                f"Person property value '{override_value}' is not a valid semver",
+                reason=UnresolvedFlagReason.MISSING_CONTEXT,
             )
 
-        if operator in SEMVER_COMPARISON_OPERATORS:
-            try:
-                flag_parsed = parse_semver(value)
-            except (ValueError, TypeError):
-                raise InconclusiveMatchError(
-                    f"Flag semver value '{value}' is not a valid semver"
-                )
-
-            if operator == "semver_eq":
-                return override_parsed == flag_parsed
-            elif operator == "semver_neq":
-                return override_parsed != flag_parsed
-            elif operator == "semver_gt":
-                return override_parsed > flag_parsed
-            elif operator == "semver_gte":
-                return override_parsed >= flag_parsed
-            elif operator == "semver_lt":
-                return override_parsed < flag_parsed
-            elif operator == "semver_lte":
-                return override_parsed <= flag_parsed
-
-        elif operator == "semver_tilde":
-            try:
-                lower, upper = _tilde_bounds(str(value))
-            except (ValueError, TypeError):
-                raise InconclusiveMatchError(
-                    f"Flag semver value '{value}' is not valid for tilde operator"
-                )
-            return lower <= override_parsed < upper
-
-        elif operator == "semver_caret":
-            try:
-                lower, upper = _caret_bounds(str(value))
-            except (ValueError, TypeError):
-                raise InconclusiveMatchError(
-                    f"Flag semver value '{value}' is not valid for caret operator"
-                )
-            return lower <= override_parsed < upper
-
-        elif operator == "semver_wildcard":
-            try:
-                lower, upper = _wildcard_bounds(str(value))
-            except (ValueError, TypeError):
-                raise InconclusiveMatchError(
-                    f"Flag semver value '{value}' is not valid for wildcard operator"
-                )
+        if operator in SEMVER_RANGE_OPERATORS:
+            lower, upper = flag_semver
             return lower <= override_parsed < upper
+        if operator == "semver_eq":
+            return override_parsed == flag_semver
+        if operator == "semver_neq":
+            return override_parsed != flag_semver
+        if operator == "semver_gt":
+            return override_parsed > flag_semver
+        if operator == "semver_gte":
+            return override_parsed >= flag_semver
+        if operator == "semver_lt":
+            return override_parsed < flag_semver
+        if operator == "semver_lte":
+            return override_parsed <= flag_semver
 
     # Unreachable: all operators in PROPERTY_OPERATORS are handled above,
     # and unknown operators are rejected at the top of this function.
-    raise InconclusiveMatchError(f"Operator {operator} {_UNHANDLED_OPERATOR_MESSAGE}")
+    raise InconclusiveMatchError(
+        f"Operator {operator} {_UNHANDLED_OPERATOR_MESSAGE}",
+        reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+    )
+
+
+_COHORT_OPERATORS = ("exact", "in", "not_in")
 
 
 def match_cohort(
@@ -1104,6 +1365,15 @@ def match_cohort(
             f"cohort {cohort_id} not found in local cohorts - likely a static cohort that requires server evaluation"
         )
 
+    # Check the operator before the members, so an unsupported operator outranks a
+    # member that is only missing context.
+    operator = property.get("operator") or "exact"
+    if operator not in _COHORT_OPERATORS:
+        raise InconclusiveMatchError(
+            f"Unsupported cohort operator: {operator}",
+            reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+        )
+
     property_group = cohort_properties[cohort_id]
     matches = match_property_group(
         property_group,
@@ -1115,13 +1385,12 @@ def match_cohort(
         device_id=device_id,
         property_matching_version=property_matching_version,
     )
+    return not matches if operator == "not_in" else matches
 
-    operator = property.get("operator") or "exact"
-    if operator in ("exact", "in"):
-        return matches
-    if operator == "not_in":
-        return not matches
-    raise InconclusiveMatchError(f"Unsupported cohort operator: {operator}")
+
+def _is_nested_property_group(prop) -> bool:
+    """Whether a cohort group entry is itself a property group, not a filter."""
+    return prop == {} or "values" in prop or prop.get("type") in ("AND", "OR")
 
 
 def match_property_group(
@@ -1151,7 +1420,7 @@ def match_property_group(
         return True
 
     decisive_result = None
-    error_matching_locally = False
+    inconclusive_reason: Optional[UnresolvedFlagReason] = None
 
     for prop in properties:
         try:
@@ -1160,7 +1429,7 @@ def match_property_group(
                     "Cohort property group entry must be an object"
                 )
 
-            if prop == {} or "values" in prop or prop.get("type") in ("AND", "OR"):
+            if _is_nested_property_group(prop):
                 matches = match_property_group(
                     prop,
                     property_values,
@@ -1213,19 +1482,101 @@ def match_property_group(
             raise
         except InconclusiveMatchError as e:
             log.debug(f"Failed to compute property {prop} locally: {e}")
-            error_matching_locally = True
+            inconclusive_reason = _pick_unresolved_reason(inconclusive_reason, e.reason)
 
     if decisive_result is not None:
         return decisive_result
-    if error_matching_locally:
+    if inconclusive_reason is not None:
         raise InconclusiveMatchError(
-            "Can't match cohort without a given cohort property value"
+            "Can't match cohort without a given cohort property value",
+            reason=inconclusive_reason,
         )
 
     # AND: every entry matched. OR: none matched.
     return is_and
 
 
+def _get_definition_unresolved_reason(
+    flag, flags_by_key, cohort_properties, group_type_mapping
+) -> Optional[UnresolvedFlagReason]:
+    """Return the unresolved reason that comes from the flag's definition alone, so
+    it is known when definitions load. Matches the reason local evaluation reports
+    for the same cause."""
+    if not flag.get("active"):
+        return None
+    if flag.get("ensure_experience_continuity"):
+        return UnresolvedFlagReason.EXPERIENCE_CONTINUITY
+    flag_filters = flag.get("filters") or {}
+    aggregation = flag_filters.get("aggregation_group_type_index")
+    if aggregation is not None and not group_type_mapping.get(str(aggregation)):
+        return UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+    for condition in flag_filters.get("groups") or []:
+        for prop in condition.get("properties") or []:
+            if _is_unsupported_property(prop, flags_by_key, cohort_properties, set()):
+                return UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+    return None
+
+
+def _is_unsupported_property(
+    prop, flags_by_key, cohort_properties, visited_cohort_ids
+) -> bool:
+    property_type = prop.get("type")
+    if property_type == "flag":
+        # A malformed condition shape is a definitive local no-match, not a gap.
+        if _flag_dependency_shape_problem(prop) is not None:
+            return False
+        dependency_chain = prop.get("dependency_chain")
+        if not isinstance(dependency_chain, list) or not dependency_chain:
+            return True
+        return any(not flags_by_key.get(key) for key in dependency_chain)
+    if property_type != "cohort":
+        try:
+            _assert_filter_supported(prop)
+        except InconclusiveMatchError:
+            return True
+        return False
+    cohort_id = str(prop.get("value"))
+    if cohort_id not in cohort_properties:
+        return True
+    if (prop.get("operator") or "exact") not in _COHORT_OPERATORS:
+        return True
+    if cohort_id in visited_cohort_ids:
+        return False
+    visited_cohort_ids.add(cohort_id)
+    return _is_unsupported_property_group(
+        cohort_properties[cohort_id],
+        flags_by_key,
+        cohort_properties,
+        visited_cohort_ids,
+    )
+
+
+def _is_unsupported_property_group(
+    property_group, flags_by_key, cohort_properties, visited_cohort_ids
+) -> bool:
+    if property_group == {}:
+        return False
+    if not isinstance(property_group, dict):
+        return True
+    values = property_group.get("values")
+    if property_group.get("type") not in ("AND", "OR") or not isinstance(values, list):
+        return True
+    for prop in values:
+        if not isinstance(prop, dict):
+            return True
+        if _is_nested_property_group(prop):
+            unsupported = _is_unsupported_property_group(
+                prop, flags_by_key, cohort_properties, visited_cohort_ids
+            )
+        else:
+            unsupported = _is_unsupported_property(
+                prop, flags_by_key, cohort_properties, visited_cohort_ids
+            )
+        if unsupported:
+            return True
+    return False
+
+
 def parse_datetime(value: str) -> datetime.datetime:
     text = value.strip()
     if text.endswith("Z"):
diff --git a/posthog/test/test_evaluate_flags.py b/posthog/test/test_evaluate_flags.py
index 32a63ab27..25ca18e51 100644
--- a/posthog/test/test_evaluate_flags.py
+++ b/posthog/test/test_evaluate_flags.py
@@ -1,3 +1,4 @@
+import logging
 import unittest
 import warnings
 from unittest import mock
@@ -6,7 +7,9 @@
 
 from posthog.client import Client
 from posthog.feature_flag_evaluations import FeatureFlagEvaluations
+from posthog.request import GetResponse
 from posthog.test.test_utils import FAKE_TEST_API_KEY
+from posthog.types import UnresolvedFlagReason
 
 
 def _flags_response_fixture():
@@ -552,6 +555,702 @@ def test_context_device_id_is_used_for_local_evaluation(
         patch_flags.assert_not_called()
 
 
+def _always_on_flag(key, **extra):
+    return {
+        "id": 1,
+        "key": key,
+        "active": True,
+        "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
+        **extra,
+    }
+
+
+def _flag_with(key, *properties, **extra):
+    flag = _always_on_flag(key, **extra)
+    flag["filters"]["groups"][0]["properties"] = list(properties)
+    return flag
+
+
+def _depends_on(key):
+    return {
+        "key": key,
+        "type": "flag",
+        "value": True,
+        "operator": "flag_evaluates_to",
+        "dependency_chain": [key],
+    }
+
+
+_PLAN_IS_PRO = {"key": "plan", "operator": "exact", "value": "pro", "type": "person"}
+_STATIC_COHORT = {"key": "id", "type": "cohort", "value": 42}
+
+
+def _flag_called_properties(patch_capture):
+    return {
+        c[1]["properties"]["$feature_flag"]: c[1]["properties"]
+        for c in patch_capture.call_args_list
+        if c[0] and c[0][0] == "$feature_flag_called"
+    }
+
+
+class TestEvaluateFlagsUnresolved(unittest.TestCase):
+    """Mirrors the ``@unresolved_flags_capable`` scenarios of the evaluate-flags spec."""
+
+    def setUp(self):
+        self.client = Client(FAKE_TEST_API_KEY, secret_key="test")
+        self.client.feature_flags = [
+            _always_on_flag("beta-ui"),
+            _always_on_flag("checkout", ensure_experience_continuity=True),
+        ]
+
+    def tearDown(self):
+        self.client.shutdown()
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_local_only_reports_experience_continuity_flag(
+        self, patch_capture, patch_flags
+    ):
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertEqual(flags.keys, ["beta-ui"])
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {"checkout": UnresolvedFlagReason.EXPERIENCE_CONTINUITY},
+        )
+        self.assertEqual(flags.unresolved_flags["checkout"], "experience_continuity")
+        patch_flags.assert_not_called()
+        self.assertEqual(_flag_called_properties(patch_capture), {})
+        self.assertEqual(flags.only_accessed().keys, [])
+        self.assertEqual(dict(flags.only(["beta-ui", "checkout"]).unresolved_flags), {})
+        self.assertIs(flags.get_flag("beta-ui"), True)
+
+    @mock.patch("posthog.client.flags")
+    def test_unresolved_flags_is_read_only(self, _patch_flags):
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        with self.assertRaises(TypeError):
+            flags.unresolved_flags["beta-ui"] = UnresolvedFlagReason.MISSING_CONTEXT  # type: ignore[index]
+
+    @parameterized.expand(
+        [
+            (
+                "missing_person_property",
+                _flag_with("checkout", _PLAN_IS_PRO),
+                {},
+                UnresolvedFlagReason.MISSING_CONTEXT,
+            ),
+            (
+                "device_bucketed_without_device_id",
+                _always_on_flag("checkout", bucketing_identifier="device_id"),
+                {},
+                UnresolvedFlagReason.MISSING_CONTEXT,
+            ),
+            (
+                "unrecognized_operator",
+                _flag_with(
+                    "checkout",
+                    {
+                        "key": "plan",
+                        "operator": "bogus",
+                        "value": "x",
+                        "type": "person",
+                    },
+                ),
+                {"person_properties": {"plan": "enterprise"}},
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "static_cohort",
+                _flag_with("checkout", _STATIC_COHORT),
+                {},
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "static_cohort_and_missing_property",
+                _flag_with("checkout", _STATIC_COHORT, _PLAN_IS_PRO),
+                {},
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "missing_property_and_static_cohort",
+                _flag_with("checkout", _PLAN_IS_PRO, _STATIC_COHORT),
+                {},
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "device_bucketed_with_static_cohort",
+                _flag_with(
+                    "checkout", _STATIC_COHORT, bucketing_identifier="device_id"
+                ),
+                {},
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+        ]
+    )
+    @mock.patch("posthog.client.flags")
+    def test_each_inconclusive_cause_reports_its_reason(
+        self, _name, checkout, call_kwargs, reason, patch_flags
+    ):
+        self.client.feature_flags = [
+            {**checkout, "ensure_experience_continuity": False}
+        ]
+
+        flags = self.client.evaluate_flags(
+            "user-123", only_evaluate_locally=True, **call_kwargs
+        )
+
+        self.assertNotIn("checkout", flags.keys)
+        self.assertEqual(dict(flags.unresolved_flags), {"checkout": reason})
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_flag_blocked_by_unresolved_dependency_reports_the_dependency(
+        self, _patch_flags
+    ):
+        self.client.feature_flags = [
+            _always_on_flag("checkout", ensure_experience_continuity=True),
+            _flag_with("beta-ui", _depends_on("checkout")),
+        ]
+
+        flags = self.client.evaluate_flags(
+            "user-123", flag_keys=["beta-ui"], only_evaluate_locally=True
+        )
+
+        self.assertNotIn("beta-ui", flags.keys)
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {"beta-ui": UnresolvedFlagReason.UNRESOLVED_DEPENDENCY},
+        )
+
+    @mock.patch("posthog.client.flags")
+    def test_dependency_in_scope_carries_its_own_reason(self, _patch_flags):
+        self.client.feature_flags = [
+            _flag_with("checkout", _PLAN_IS_PRO),
+            _flag_with("beta-ui", _depends_on("checkout")),
+        ]
+
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {
+                "checkout": UnresolvedFlagReason.MISSING_CONTEXT,
+                "beta-ui": UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            },
+        )
+
+    @mock.patch("posthog.client.flags")
+    def test_flag_depending_on_flag_without_definition_is_unsupported_definition(
+        self, _patch_flags
+    ):
+        self.client.feature_flags = [_flag_with("beta-ui", _depends_on("checkout"))]
+
+        flags = self.client.evaluate_flags(
+            "user-123", flag_keys=["beta-ui"], only_evaluate_locally=True
+        )
+
+        self.assertNotIn("beta-ui", flags.keys)
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {"beta-ui": UnresolvedFlagReason.UNSUPPORTED_DEFINITION},
+        )
+
+    @staticmethod
+    def _target_depending_on(dep_property):
+        """``target`` is ``a`` when ``dep`` is true, and ``b`` for everyone else."""
+        target = _always_on_flag("target")
+        target["filters"] = {
+            "groups": [
+                {
+                    "properties": [_depends_on("dep")],
+                    "rollout_percentage": 100,
+                    "variant": "a",
+                },
+                {"properties": [], "rollout_percentage": 100, "variant": "b"},
+            ],
+            "multivariate": {
+                "variants": [
+                    {"key": "a", "rollout_percentage": 50},
+                    {"key": "b", "rollout_percentage": 50},
+                ]
+            },
+        }
+        return [_flag_with("dep", dep_property), target]
+
+    @parameterized.expand([("all_flags", None), ("target_only", ["target"])])
+    @mock.patch("posthog.client.flags")
+    def test_dependency_that_needs_the_server_falls_back_to_the_server(
+        self, _name, flag_keys, patch_flags
+    ):
+        self.client.feature_flags = self._target_depending_on(
+            {"key": "id", "type": "cohort", "value": 999}
+        )
+        patch_flags.return_value = {
+            "flags": {"target": {"enabled": True, "variant": "a"}}
+        }
+
+        flags = self.client.evaluate_flags("user-123", flag_keys=flag_keys)
+
+        self.assertEqual(flags.get_flag("target"), "a")
+        patch_flags.assert_called_once()
+
+    @parameterized.expand(
+        [
+            ("not_an_object", "not-a-filter"),
+            ("dependency_without_key", {**_depends_on("dep"), "key": None}),
+        ]
+    )
+    @mock.patch("posthog.client.flags")
+    def test_dependency_that_needs_the_server_falls_back_despite_malformed_later_condition(
+        self, _name, malformed_filter, patch_flags
+    ):
+        dep, target = self._target_depending_on(
+            {"key": "id", "type": "cohort", "value": 999}
+        )
+        target["filters"]["groups"][1]["properties"] = [malformed_filter]
+        self.client.feature_flags = [dep, target]
+        patch_flags.return_value = {
+            "flags": {"target": {"enabled": True, "variant": "a"}}
+        }
+
+        with mock.patch.object(self.client.log, "exception") as patch_exception:
+            flags = self.client.evaluate_flags("user-123", flag_keys=["target"])
+
+        self.assertEqual(flags.get_flag("target"), "a")
+        patch_flags.assert_called_once()
+        patch_exception.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_dependency_that_needs_the_server_leaves_flag_unresolved_locally(
+        self, patch_flags
+    ):
+        self.client.feature_flags = self._target_depending_on(
+            {"key": "id", "type": "cohort", "value": 999}
+        )
+
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertNotIn("target", flags.keys)
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {
+                "dep": UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+                "target": UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            },
+        )
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_dependency_resolved_locally_picks_its_condition(self, patch_flags):
+        self.client.feature_flags = self._target_depending_on(_PLAN_IS_PRO)
+
+        flags = self.client.evaluate_flags(
+            "user-123", person_properties={"plan": "pro"}
+        )
+
+        self.assertEqual(flags.get_flag("target"), "a")
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_flag_resolved_by_remote_fallback_is_not_unresolved(self, patch_flags):
+        patch_flags.return_value = {
+            "flags": {"checkout": {"enabled": True, "variant": None}}
+        }
+
+        flags = self.client.evaluate_flags("user-123")
+
+        self.assertIs(flags.get_flag("checkout"), True)
+        self.assertEqual(sorted(flags.keys), ["beta-ui", "checkout"])
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        patch_flags.assert_called_once()
+
+    @parameterized.expand(
+        [
+            (
+                "request_fails",
+                Exception("flags request failed"),
+                {},
+                "local_evaluation_inconclusive",
+            ),
+            ("returns_no_flags", None, {}, "local_evaluation_inconclusive"),
+            (
+                "errors_while_computing",
+                None,
+                {"errorsWhileComputingFlags": True},
+                "errors_while_computing_flags,local_evaluation_inconclusive",
+            ),
+        ]
+    )
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_flag_left_without_remote_value_is_unresolved(
+        self,
+        _name,
+        side_effect,
+        extra_response,
+        expected_error,
+        patch_capture,
+        patch_flags,
+    ):
+        patch_flags.side_effect = side_effect
+        patch_flags.return_value = {"flags": {}, **extra_response}
+
+        flags = self.client.evaluate_flags("user-123")
+
+        self.assertNotIn("checkout", flags.keys)
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {"checkout": UnresolvedFlagReason.EXPERIENCE_CONTINUITY},
+        )
+        flags.is_enabled("checkout")
+        properties = _flag_called_properties(patch_capture)["checkout"]
+        self.assertEqual(properties["$feature_flag_error"], expected_error)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_key_without_local_definition_is_missing_not_unresolved(
+        self, patch_capture, patch_flags
+    ):
+        self.client.feature_flags = [_always_on_flag("beta-ui")]
+        patch_flags.return_value = {"flags": {}}
+
+        flags = self.client.evaluate_flags(
+            "user-123", flag_keys=["beta-ui", "typo-flag"]
+        )
+        flags.is_enabled("typo-flag")
+
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        properties = _flag_called_properties(patch_capture)["typo-flag"]
+        self.assertEqual(properties["$feature_flag_error"], "flag_missing")
+
+    @mock.patch("posthog.client.flags")
+    def test_flag_outside_requested_keys_is_not_unresolved(self, patch_flags):
+        flags = self.client.evaluate_flags("user-123", flag_keys=["beta-ui"])
+
+        self.assertEqual(flags.keys, ["beta-ui"])
+        self.assertTrue(flags.is_enabled("beta-ui"))
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_inactive_flag_is_false_not_unresolved(self, patch_flags):
+        self.client.feature_flags = [
+            _always_on_flag("checkout", active=False, ensure_experience_continuity=True)
+        ]
+
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertEqual(flags.keys, ["checkout"])
+        self.assertIs(flags.get_flag("checkout"), False)
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_reading_remote_resolved_flag_reports_no_error(
+        self, patch_capture, patch_flags
+    ):
+        patch_flags.return_value = {
+            "flags": {"checkout": {"enabled": True, "variant": None}}
+        }
+
+        flags = self.client.evaluate_flags("user-123")
+
+        self.assertTrue(flags.is_enabled("checkout"))
+        properties = _flag_called_properties(patch_capture)["checkout"]
+        self.assertIs(properties["$feature_flag_response"], True)
+        self.assertNotIn("$feature_flag_error", properties)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_reading_unresolved_flag_reports_local_evaluation_inconclusive(
+        self, patch_capture, _patch_flags
+    ):
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertFalse(flags.is_enabled("checkout"))
+        properties = _flag_called_properties(patch_capture)["checkout"]
+        self.assertEqual(
+            properties["$feature_flag_error"], "local_evaluation_inconclusive"
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_filtered_snapshots_carry_no_unresolved_flags(
+        self, patch_capture, _patch_flags
+    ):
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+        flags.is_enabled("beta-ui")
+
+        for filtered in (flags.only(["beta-ui"]), flags.only_accessed()):
+            self.assertEqual(dict(filtered.unresolved_flags), {})
+            filtered.get_flag("checkout")
+            properties = _flag_called_properties(patch_capture)["checkout"]
+            self.assertEqual(properties["$feature_flag_error"], "flag_missing")
+        self.assertEqual(
+            dict(flags.unresolved_flags),
+            {"checkout": UnresolvedFlagReason.EXPERIENCE_CONTINUITY},
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_unexpected_error_is_missing_not_unresolved(
+        self, patch_capture, _patch_flags
+    ):
+        broken = _always_on_flag("checkout")
+        broken["filters"]["groups"][0]["rollout_percentage"] = "abc"
+        self.client.feature_flags = [broken]
+
+        flags = self.client.evaluate_flags("user-123", only_evaluate_locally=True)
+        flags.is_enabled("checkout")
+
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        properties = _flag_called_properties(patch_capture)["checkout"]
+        self.assertEqual(properties["$feature_flag_error"], "flag_missing")
+
+    @mock.patch("posthog.client.flags")
+    def test_filter_that_does_not_match_resolves_flag_locally(self, patch_flags):
+        self.client.feature_flags = [
+            _flag_with(
+                "checkout",
+                _STATIC_COHORT,
+                {"key": "plan", "operator": "exact", "value": "free"},
+            )
+        ]
+
+        flags = self.client.evaluate_flags(
+            "user-123", person_properties={"plan": "pro"}
+        )
+
+        self.assertIs(flags.get_flag("checkout"), False)
+        self.assertEqual(dict(flags.unresolved_flags), {})
+        patch_flags.assert_not_called()
+
+
+class TestUnresolvableFlagWarning(unittest.TestCase):
+    """Mirrors the ``@unresolvable_flag_warning_capable`` scenarios of the evaluate-flags spec."""
+
+    def _client(self, **kwargs):
+        client = Client(
+            FAKE_TEST_API_KEY,
+            secret_key="test",
+            enable_local_evaluation=False,
+            send=False,
+            **kwargs,
+        )
+        self.addCleanup(client.shutdown)
+        return client
+
+    @staticmethod
+    def _definitions(*flags):
+        return {"flags": list(flags), "group_type_mapping": {}, "cohorts": {}}
+
+    @staticmethod
+    def _refresh(client, response):
+        with mock.patch("posthog.client.get", return_value=response):
+            client._load_feature_flags()
+
+    def _refresh_with(self, client, *flags):
+        self._refresh(
+            client,
+            GetResponse(data=self._definitions(*flags), etag=None, not_modified=False),
+        )
+
+    @staticmethod
+    def _warnings(logs, key, reason):
+        return [
+            record
+            for record in logs.records
+            if record.levelno == logging.WARNING
+            and f"(reason: {reason})" in record.getMessage()
+            and key in record.getMessage()
+        ]
+
+    @parameterized.expand(
+        [("unchanged_definitions",), ("not_modified",), ("shared_cache_load",)]
+    )
+    @mock.patch("posthog.client.flags")
+    def test_loading_never_resolvable_definition_logs_one_warning(
+        self, refresh_result, patch_flags
+    ):
+        definitions = self._definitions(
+            _always_on_flag("checkout", ensure_experience_continuity=True),
+            _always_on_flag("beta-ui"),
+        )
+        cache_provider = mock.Mock()
+        cache_provider.should_fetch_flag_definitions.return_value = False
+        cache_provider.get_flag_definitions.return_value = definitions
+        client = self._client(
+            flag_definition_cache_provider=(
+                cache_provider if refresh_result == "shared_cache_load" else None
+            )
+        )
+        self.assertFalse(client.debug)
+
+        with self.assertLogs("posthog", level=logging.DEBUG) as logs:
+            if refresh_result == "shared_cache_load":
+                client._load_feature_flags()
+                client._load_feature_flags()
+            else:
+                self._refresh(
+                    client,
+                    GetResponse(data=definitions, etag="etag-1", not_modified=False),
+                )
+                self._refresh(
+                    client,
+                    GetResponse(data=None, etag="etag-1", not_modified=True)
+                    if refresh_result == "not_modified"
+                    else GetResponse(
+                        data=definitions, etag="etag-2", not_modified=False
+                    ),
+                )
+
+        warnings_logged = self._warnings(logs, "checkout", "experience_continuity")
+        self.assertEqual(len(warnings_logged), 1)
+        self.assertNotIn("beta-ui", warnings_logged[0].getMessage())
+        self.assertTrue(client.log.isEnabledFor(logging.WARNING))
+        patch_flags.assert_not_called()
+
+    @mock.patch("posthog.client.flags")
+    def test_changed_definition_logs_warning_again(self, patch_flags):
+        client = self._client()
+        checkout = _always_on_flag("checkout", ensure_experience_continuity=True)
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(client, checkout)
+            self._refresh_with(client, {**checkout, "id": 2})
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", "experience_continuity")), 2
+        )
+        patch_flags.assert_not_called()
+
+    def test_change_to_another_flag_does_not_repeat_warning(self):
+        client = self._client()
+        checkout = _always_on_flag("checkout", ensure_experience_continuity=True)
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(client, checkout, _always_on_flag("beta-ui"))
+            self._refresh_with(client, checkout, _always_on_flag("beta-ui", id=2))
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", "experience_continuity")), 1
+        )
+
+    @parameterized.expand(
+        [
+            ("static_cohort", _flag_with("checkout", _STATIC_COHORT)),
+            (
+                "unknown_operator",
+                _flag_with(
+                    "checkout", {"key": "plan", "operator": "bogus", "value": "x"}
+                ),
+            ),
+            (
+                "malformed_value",
+                _flag_with(
+                    "checkout",
+                    {"key": "since", "operator": "is_date_after", "value": "x"},
+                ),
+            ),
+            ("missing_dependency", _flag_with("checkout", _depends_on("missing"))),
+            (
+                "circular_dependency",
+                _flag_with(
+                    "checkout", {**_depends_on("checkout"), "dependency_chain": []}
+                ),
+            ),
+        ]
+    )
+    def test_unsupported_definition_logs_warning(self, _name, checkout):
+        client = self._client()
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(client, checkout)
+            self._refresh_with(client, checkout)
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", "unsupported_definition")), 1
+        )
+
+    def test_does_not_warn_for_flags_that_depend_on_the_call(self):
+        client = self._client()
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(
+                client,
+                _always_on_flag("continuity", ensure_experience_continuity=True),
+                _always_on_flag(
+                    "inactive", active=False, ensure_experience_continuity=True
+                ),
+                _flag_with("needs-plan", _PLAN_IS_PRO),
+                _flag_with("dependent", _depends_on("continuity")),
+            )
+
+        messages = " ".join(record.getMessage() for record in logs.records)
+        self.assertIn("continuity", messages)
+        for key in ("inactive", "needs-plan", "dependent"):
+            self.assertNotIn(key, messages)
+
+    def test_malformed_flag_does_not_block_other_warnings(self):
+        client = self._client()
+        broken = {"key": "broken", "active": True, "filters": {"groups": [None]}}
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(
+                client,
+                broken,
+                _always_on_flag("checkout", ensure_experience_continuity=True),
+            )
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", "experience_continuity")), 1
+        )
+
+    def test_removed_flag_is_forgotten_and_warns_again_when_it_returns(self):
+        client = self._client()
+        checkout = _always_on_flag("checkout", ensure_experience_continuity=True)
+
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_with(client, checkout)
+            self._refresh_with(client, _always_on_flag("beta-ui"))
+            self.assertEqual(client._warned_unresolvable_flags, {})
+            self._refresh_with(client, checkout)
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", "experience_continuity")), 2
+        )
+
+    def test_classifies_and_logs_outside_the_publication_lock(self):
+        client = self._client()
+        lock = client._flag_definition_publication_lock
+        lock_held = []
+        classify = Client._classify_unresolvable_flags
+
+        def record_lock_and_classify(snapshot):
+            lock_held.append(lock._is_owned())
+            return classify(snapshot)
+
+        with (
+            mock.patch.object(
+                Client,
+                "_classify_unresolvable_flags",
+                side_effect=record_lock_and_classify,
+            ),
+            mock.patch.object(
+                client.log,
+                "warning",
+                side_effect=lambda *args, **kwargs: lock_held.append(lock._is_owned()),
+            ),
+        ):
+            self._refresh_with(
+                client, _always_on_flag("checkout", ensure_experience_continuity=True)
+            )
+
+        self.assertEqual(lock_held, [False, False])
+
+
 class TestEvaluateFlagsFiltering(unittest.TestCase):
     def setUp(self):
         self.client = Client(FAKE_TEST_API_KEY)
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index 2c430336d..14a1ed18e 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -19,14 +19,17 @@
     _UNHANDLED_OPERATOR_MESSAGE,
     InconclusiveMatchError,
     RequiresServerEvaluation,
+    _get_definition_unresolved_reason,
+    _pick_unresolved_reason,
     match_cohort,
+    match_feature_flag_properties,
     match_property,
     match_property_group,
     parse_datetime,
     relative_date_parse_for_feature_flag_matching,
 )
 from posthog.request import APIError, GetResponse
-from posthog.types import FeatureFlagEvaluationRuntime
+from posthog.types import FeatureFlagEvaluationRuntime, UnresolvedFlagReason
 from posthog.test.test_utils import FAKE_TEST_API_KEY
 from posthog.utils import FlagCache
 
@@ -2006,14 +2009,15 @@ def test_feature_flags_with_flag_dependencies(self, patch_flags, mock_log):
         self.assertEqual(patch_flags.call_count, 1)
         patch_load.assert_not_called()
 
-        # Test with email that doesn't match (should also fall back to remote due to missing dependency)
+        # An email that doesn't match rules the condition out whatever the missing
+        # dependency would evaluate to, so the flag resolves locally.
         feature_flag_match = client.get_feature_flag(
             "flag-with-dependencies",
             "test-user-2",
             person_properties={"email": "test@other.com"},
         )
-        self.assertIsNone(feature_flag_match)
-        self.assertEqual(patch_flags.call_count, 2)  # Called twice now
+        self.assertIs(feature_flag_match, False)
+        self.assertEqual(patch_flags.call_count, 1)
         patch_load.assert_not_called()
 
     @mock.patch("posthog.client.flags")
@@ -5367,6 +5371,153 @@ def property(self, key, value, operator=None):
 
         return result
 
+    @parameterized.expand(
+        [
+            ("unknown_operator", "x", "bogus", {"key": "x"}, "UNSUPPORTED_DEFINITION"),
+            ("missing_property", "x", "exact", {}, "MISSING_CONTEXT"),
+            (
+                "invalid_flag_date",
+                "not-a-date",
+                "is_date_before",
+                {"key": "2024-01-01"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "invalid_property_date",
+                "2024-01-01",
+                "is_date_before",
+                {"key": "not-a-date"},
+                "MISSING_CONTEXT",
+            ),
+            (
+                "invalid_flag_semver",
+                "x.y",
+                "semver_gt",
+                {"key": "1.2.3"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "invalid_property_semver",
+                "1.2.3",
+                "semver_gt",
+                {"key": "x.y"},
+                "MISSING_CONTEXT",
+            ),
+            (
+                "invalid_flag_and_property_semver",
+                "x.y",
+                "semver_gt",
+                {"key": "a.b"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "invalid_flag_semver_and_missing_property",
+                "x.y",
+                "semver_gt",
+                {},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "invalid_flag_wildcard_and_property",
+                "1x.*",
+                "semver_wildcard",
+                {"key": "a.b"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "boolean_flag_date",
+                True,
+                "is_date_after",
+                {"key": "2024-01-01"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "non_date_property",
+                "2024-01-01",
+                "is_date_after",
+                {"key": 5},
+                "MISSING_CONTEXT",
+            ),
+            (
+                "invalid_flag_number",
+                "abc",
+                "gt",
+                {"key": 5},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "invalid_flag_number_and_missing_property",
+                "abc",
+                "gt",
+                {},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "non_json_property",
+                "x",
+                "exact",
+                {"key": object()},
+                "MISSING_CONTEXT",
+            ),
+            (
+                "non_finite_property",
+                "x",
+                "icontains",
+                {"key": float("nan")},
+                "MISSING_CONTEXT",
+            ),
+            (
+                "non_finite_flag_value",
+                float("nan"),
+                "exact",
+                {"key": "x"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "non_finite_flag_value_and_property",
+                [float("inf")],
+                "exact",
+                {"key": float("nan")},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "non_finite_flag_value_and_missing_property",
+                float("nan"),
+                "icontains",
+                {},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "deferred_regex",
+                r"\bfoo",
+                "regex",
+                {"key": "foo"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "deferred_regex_and_missing_property",
+                r"\bfoo",
+                "regex",
+                {},
+                "UNSUPPORTED_DEFINITION",
+            ),
+            (
+                "regex_deferred_for_property_value",
+                r"\w+",
+                "regex",
+                {"key": "é"},
+                "UNSUPPORTED_DEFINITION",
+            ),
+        ]
+    )
+    def test_inconclusive_match_reports_reason(
+        self, _name, value, operator, properties, reason
+    ):
+        with self.assertRaises(InconclusiveMatchError) as ctx:
+            match_property(self.property("key", value, operator), properties)
+
+        self.assertEqual(ctx.exception.reason, UnresolvedFlagReason[reason])
+
     def test_every_supported_operator_has_a_dispatch_branch(self):
         # PROPERTY_OPERATORS gates local evaluation, but match_property dispatches
         # on a hand-written if-chain. An operator listed in the tuple but missing a
@@ -6403,6 +6554,399 @@ def test_unknown_operator(self):
         )
 
 
+PLAN_IS_PRO = {"key": "plan", "operator": "exact", "value": "pro", "type": "person"}
+PLAN_IS_FREE = {"key": "plan", "operator": "exact", "value": "free", "type": "person"}
+EMAIL_IS_SET = {"key": "email", "operator": "is_set", "type": "person"}
+UNKNOWN_OPERATOR = {"key": "plan", "operator": "bogus", "value": "x", "type": "person"}
+STATIC_COHORT = {"key": "id", "value": 42, "type": "cohort"}
+
+
+def _depends_on(key):
+    return {
+        "key": key,
+        "type": "flag",
+        "value": True,
+        "operator": "flag_evaluates_to",
+        "dependency_chain": [key],
+    }
+
+
+def _flag(key, *conditions, **extra):
+    return {
+        "key": key,
+        "active": True,
+        "filters": {
+            "groups": [
+                {"properties": list(properties), "rollout_percentage": 100}
+                for properties in conditions
+            ]
+        },
+        **extra,
+    }
+
+
+class TestUnresolvedReasons(unittest.TestCase):
+    def evaluate(self, flag, properties, flags=(), cohorts=None):
+        return match_feature_flag_properties(
+            flag,
+            "user-123",
+            properties,
+            cohort_properties=cohorts or {},
+            flags_by_key={f["key"]: f for f in (flag, *flags)},
+            evaluation_cache={},
+            bucketing_value="user-123",
+        )
+
+    def assert_unresolved(
+        self, error_type, reason, flag, properties, flags=(), cohorts=None
+    ):
+        with self.assertRaises(error_type) as ctx:
+            self.evaluate(flag, properties, flags, cohorts)
+        self.assertIs(type(ctx.exception), error_type)
+        self.assertEqual(ctx.exception.reason, reason)
+
+    @parameterized.expand(
+        [
+            (
+                "experience_continuity_first",
+                [None, UnresolvedFlagReason.EXPERIENCE_CONTINUITY],
+                UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+            ),
+            (
+                "unsupported_over_missing",
+                [
+                    UnresolvedFlagReason.MISSING_CONTEXT,
+                    UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+                ],
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "dependency_over_missing",
+                [
+                    UnresolvedFlagReason.MISSING_CONTEXT,
+                    UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+                ],
+                UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            ),
+            (
+                "unsupported_kept_over_dependency",
+                [
+                    UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+                    UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+                ],
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "experience_continuity_kept",
+                [
+                    UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+                    UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+                ],
+                UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+            ),
+        ]
+    )
+    def test_pick_unresolved_reason_follows_spec_order(self, _name, reasons, expected):
+        current, new = reasons
+        self.assertEqual(_pick_unresolved_reason(current, new), expected)
+
+    @parameterized.expand(
+        [
+            ("missing_property_first", [EMAIL_IS_SET, PLAN_IS_FREE]),
+            ("missing_property_last", [PLAN_IS_FREE, EMAIL_IS_SET]),
+            ("static_cohort_first", [STATIC_COHORT, PLAN_IS_FREE]),
+            ("unknown_operator_first", [UNKNOWN_OPERATOR, PLAN_IS_FREE]),
+        ]
+    )
+    def test_filter_that_does_not_match_rules_condition_out(self, _name, properties):
+        self.assertIs(
+            self.evaluate(_flag("checkout", properties), {"plan": "pro"}), False
+        )
+
+        with self.assertRaises((InconclusiveMatchError, RequiresServerEvaluation)):
+            self.evaluate(_flag("checkout", properties), {"plan": "free"})
+
+    def test_condition_reports_highest_precedence_reason(self):
+        self.assert_unresolved(
+            InconclusiveMatchError,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            _flag("checkout", [PLAN_IS_PRO, UNKNOWN_OPERATOR]),
+            {},
+        )
+
+    def test_static_cohort_first_unchecked_filter_requires_server(self):
+        self.assert_unresolved(
+            RequiresServerEvaluation,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            _flag("checkout", [STATIC_COHORT, PLAN_IS_PRO]),
+            {},
+        )
+
+    def test_static_cohort_after_unchecked_filter_lets_later_conditions_resolve(self):
+        flag = _flag("checkout", [PLAN_IS_PRO, STATIC_COHORT], [EMAIL_IS_SET])
+
+        self.assertIs(self.evaluate(flag, {"email": "a@b.c"}), True)
+        self.assert_unresolved(
+            InconclusiveMatchError,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            flag,
+            {},
+        )
+
+    def test_later_static_cohort_condition_keeps_higher_precedence_reason(self):
+        self.assert_unresolved(
+            RequiresServerEvaluation,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            _flag("checkout", [PLAN_IS_PRO], [STATIC_COHORT]),
+            {},
+        )
+
+    @parameterized.expand(
+        [
+            ("dependency_only", [[_depends_on("base")]], "unresolved_dependency"),
+            (
+                "unknown_operator_first",
+                [[UNKNOWN_OPERATOR], [_depends_on("base")]],
+                "unsupported_definition",
+            ),
+            (
+                "dependency_first",
+                [[_depends_on("base")], [UNKNOWN_OPERATOR]],
+                "unsupported_definition",
+            ),
+            (
+                "dependency_reused_after_unchecked_filter",
+                [[EMAIL_IS_SET, _depends_on("base")], [_depends_on("base")]],
+                "unresolved_dependency",
+            ),
+            (
+                "unknown_operator_after_dependency_in_same_condition",
+                [[_depends_on("base"), UNKNOWN_OPERATOR]],
+                "unsupported_definition",
+            ),
+            (
+                "cohort_with_dependency_first",
+                [[{"key": "id", "value": 1, "type": "cohort"}]],
+                "unsupported_definition",
+            ),
+            (
+                "cohort_with_unknown_operator_first",
+                [[{"key": "id", "value": 2, "type": "cohort"}]],
+                "unsupported_definition",
+            ),
+        ]
+    )
+    def test_dependency_requiring_server_requires_server(
+        self, _name, conditions, reason
+    ):
+        cohorts = {
+            "1": {"type": "AND", "values": [_depends_on("base"), UNKNOWN_OPERATOR]},
+            "2": {"type": "AND", "values": [UNKNOWN_OPERATOR, _depends_on("base")]},
+        }
+
+        self.assert_unresolved(
+            RequiresServerEvaluation,
+            UnresolvedFlagReason(reason),
+            _flag("checkout", *conditions),
+            {"plan": "pro"},
+            flags=[_flag("base", [STATIC_COHORT])],
+            cohorts=cohorts,
+        )
+
+    def test_unexpected_error_after_inconclusive_filter_lets_later_conditions_resolve(
+        self,
+    ):
+        malformed_filter = "not-a-filter"
+
+        self.assertIs(
+            self.evaluate(
+                _flag("checkout", [PLAN_IS_PRO, malformed_filter], [EMAIL_IS_SET]),
+                {"email": "a@b.c"},
+            ),
+            True,
+        )
+        with self.assertRaises(AttributeError):
+            self.evaluate(
+                _flag("checkout", [malformed_filter, PLAN_IS_PRO], [EMAIL_IS_SET]),
+                {"email": "a@b.c"},
+            )
+
+    def test_dependency_with_experience_continuity_is_unresolved_dependency(self):
+        base = _flag("base", [], ensure_experience_continuity=True)
+
+        self.assert_unresolved(
+            InconclusiveMatchError,
+            UnresolvedFlagReason.UNRESOLVED_DEPENDENCY,
+            _flag("checkout", [_depends_on("base")]),
+            {},
+            flags=[base],
+        )
+
+    def test_inactive_dependency_with_experience_continuity_is_false(self):
+        base = _flag("base", [], active=False, ensure_experience_continuity=True)
+        checkout = _flag("checkout", [{**_depends_on("base"), "value": False}])
+
+        self.assertIs(self.evaluate(checkout, {}, flags=[base]), True)
+
+    def test_missing_dependency_outranks_inconclusive_one_earlier_in_chain(self):
+        base = _flag("base", [PLAN_IS_PRO])
+        dependency = {**_depends_on("missing"), "dependency_chain": ["base", "missing"]}
+
+        self.assert_unresolved(
+            InconclusiveMatchError,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            _flag("checkout", [dependency]),
+            {},
+            flags=[base],
+        )
+
+    @parameterized.expand(
+        [
+            ("circular", []),
+            ("not_a_list", None),
+        ]
+    )
+    def test_malformed_dependency_chain_is_unsupported_definition(
+        self, _name, dependency_chain
+    ):
+        dependency = {**_depends_on("base"), "dependency_chain": dependency_chain}
+
+        self.assert_unresolved(
+            InconclusiveMatchError,
+            UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            _flag("checkout", [dependency]),
+            {},
+            flags=[_flag("base", [])],
+        )
+
+    def test_missing_group_properties_is_missing_context(self):
+        flag = _flag("checkout", [])
+        flag["filters"]["groups"][0]["aggregation_group_type_index"] = 0
+
+        with self.assertRaises(InconclusiveMatchError) as ctx:
+            match_feature_flag_properties(
+                flag,
+                "user-123",
+                {},
+                flags_by_key={"checkout": flag},
+                evaluation_cache={},
+                bucketing_value="user-123",
+                group_type_mapping={"0": "company"},
+                groups={"company": "acme"},
+            )
+        self.assertEqual(ctx.exception.reason, UnresolvedFlagReason.MISSING_CONTEXT)
+
+    def test_unsupported_cohort_operator_outranks_member_missing_context(self):
+        with self.assertRaises(InconclusiveMatchError) as ctx:
+            match_cohort(
+                {"key": "id", "value": 1, "type": "cohort", "operator": "bogus"},
+                {},
+                {"1": {"type": "AND", "values": [PLAN_IS_PRO]}},
+            )
+        self.assertEqual(
+            ctx.exception.reason, UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+        )
+
+    def test_cohort_group_keeps_highest_precedence_reason(self):
+        with self.assertRaises(InconclusiveMatchError) as ctx:
+            match_property_group(
+                {"type": "AND", "values": [PLAN_IS_PRO, UNKNOWN_OPERATOR]}, {}, {}
+            )
+        self.assertEqual(
+            ctx.exception.reason, UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+        )
+
+    @parameterized.expand(
+        [
+            ("resolvable", _flag("checkout", [PLAN_IS_PRO]), None),
+            ("inactive", _flag("checkout", [STATIC_COHORT], active=False), None),
+            (
+                "experience_continuity",
+                _flag("checkout", [STATIC_COHORT], ensure_experience_continuity=True),
+                UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+            ),
+            (
+                "static_cohort",
+                _flag("checkout", [PLAN_IS_PRO], [STATIC_COHORT]),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "unknown_operator",
+                _flag("checkout", [UNKNOWN_OPERATOR]),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "malformed_value",
+                _flag(
+                    "checkout",
+                    [{"key": "n", "operator": "gt", "value": "abc", "type": "person"}],
+                ),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "missing_dependency",
+                _flag("checkout", [_depends_on("missing")]),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "circular_dependency",
+                _flag(
+                    "checkout", [{**_depends_on("checkout"), "dependency_chain": []}]
+                ),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "malformed_dependency_shape",
+                _flag("checkout", [{**_depends_on("missing"), "operator": "exact"}]),
+                None,
+            ),
+            (
+                "unknown_group_type",
+                {
+                    **_flag("checkout", []),
+                    "filters": {"aggregation_group_type_index": 9, "groups": []},
+                },
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "static_cohort_nested_in_cohort",
+                _flag("checkout", [{"key": "id", "value": 1, "type": "cohort"}]),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+            (
+                "cohort_cycle",
+                _flag("checkout", [{"key": "id", "value": 2, "type": "cohort"}]),
+                None,
+            ),
+            (
+                "unknown_cohort_operator",
+                _flag(
+                    "checkout",
+                    [{"key": "id", "value": 2, "type": "cohort", "operator": "bogus"}],
+                ),
+                UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            ),
+        ]
+    )
+    def test_definition_unresolved_reason(self, _name, flag, expected):
+        cohorts = {
+            "1": {"type": "OR", "values": [STATIC_COHORT]},
+            "2": {
+                "type": "OR",
+                "values": [{"key": "id", "value": 3, "type": "cohort"}],
+            },
+            "3": {
+                "type": "OR",
+                "values": [{"key": "id", "value": 2, "type": "cohort"}],
+            },
+        }
+
+        self.assertEqual(
+            _get_definition_unresolved_reason(flag, {flag["key"]: flag}, cohorts, {}),
+            expected,
+        )
+
+
 class TestDateParsing(unittest.TestCase):
     @parameterized.expand(
         [
diff --git a/posthog/types.py b/posthog/types.py
index 308339319..994b0786c 100644
--- a/posthog/types.py
+++ b/posthog/types.py
@@ -99,6 +99,32 @@ def matches(self, other: "FeatureFlagEvaluationRuntime") -> bool:
         return self is other or FeatureFlagEvaluationRuntime.ALL in (self, other)
 
 
+class UnresolvedFlagReason(str, Enum):
+    """Why local evaluation left a flag without a value.
+
+    Reported by :attr:`FeatureFlagEvaluations.unresolved_flags`. Inheriting from
+    ``str`` keeps the members directly comparable to their string values. When more
+    than one cause applies, the first reason in the order below is reported.
+
+    Values:
+        EXPERIENCE_CONTINUITY: The flag has experience continuity enabled, which
+            local evaluation never resolves. Change the flag to fix it.
+        UNSUPPORTED_DEFINITION: The flag uses something the local evaluator does not
+            support, such as a static cohort, an unknown operator, a malformed value,
+            a dependency with no loaded definition or a circular dependency. Change
+            the flag or upgrade the SDK to fix it.
+        UNRESOLVED_DEPENDENCY: A flag this flag depends on has a loaded definition
+            but was unresolved.
+        MISSING_CONTEXT: The call did not pass a property, group property or device
+            id the flag needs, or passed it in an unusable form. Pass it to fix it.
+    """
+
+    EXPERIENCE_CONTINUITY = "experience_continuity"
+    UNSUPPORTED_DEFINITION = "unsupported_definition"
+    UNRESOLVED_DEPENDENCY = "unresolved_dependency"
+    MISSING_CONTEXT = "missing_context"
+
+
 @dataclass(frozen=True)
 class FlagReason:
     """Reason metadata returned by the feature flag API.
@@ -422,6 +448,8 @@ class FeatureFlagError:
     Error values:
         ERRORS_WHILE_COMPUTING: Server returned errorsWhileComputingFlags=true
         FLAG_MISSING: Requested flag not in API response
+        LOCAL_EVALUATION_INCONCLUSIVE: Requested flag has a loaded definition but
+            local evaluation was inconclusive and no remote value filled the gap
         QUOTA_LIMITED: Rate/quota limit exceeded
         TIMEOUT: Request timed out
         CONNECTION_ERROR: Network connectivity issue
@@ -433,6 +461,7 @@ class FeatureFlagError:
 
     ERRORS_WHILE_COMPUTING = "errors_while_computing_flags"
     FLAG_MISSING = "flag_missing"
+    LOCAL_EVALUATION_INCONCLUSIVE = "local_evaluation_inconclusive"
     QUOTA_LIMITED = "quota_limited"
     TIMEOUT = "timeout"
     CONNECTION_ERROR = "connection_error"
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 6c7ff2b92..63ce6a504 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -30,6 +30,7 @@ alias posthog.OptionalSetArgs -> posthog.args.OptionalSetArgs
 alias posthog.RequiresServerEvaluation -> posthog.feature_flags.RequiresServerEvaluation
 alias posthog.SocketOptions -> posthog.request.SocketOptions
 alias posthog.Span -> posthog.tracing.span.Span
+alias posthog.UnresolvedFlagReason -> posthog.types.UnresolvedFlagReason
 alias posthog.VERSION -> posthog.version.VERSION
 alias posthog.ai.PromptResult -> posthog.ai.prompts.PromptResult
 alias posthog.ai.PromptSource -> posthog.ai.prompts.PromptSource
@@ -274,6 +275,7 @@ alias posthog.client.RequiresServerEvaluation -> posthog.feature_flags.RequiresS
 alias posthog.client.SendFeatureFlagsOptions -> posthog.types.SendFeatureFlagsOptions
 alias posthog.client.SizeLimitedDict -> posthog.utils.SizeLimitedDict
 alias posthog.client.Span -> posthog.tracing.span.Span
+alias posthog.client.UnresolvedFlagReason -> posthog.types.UnresolvedFlagReason
 alias posthog.client.VERSION -> posthog.version.VERSION
 alias posthog.client.batch_post -> posthog.request.batch_post
 alias posthog.client.clean -> posthog.utils.clean
@@ -320,7 +322,9 @@ alias posthog.exception_capture.Client -> posthog.client.Client
 alias posthog.exception_utils.ExcInfo -> posthog.args.ExcInfo
 alias posthog.exception_utils.ExceptionArg -> posthog.args.ExceptionArg
 alias posthog.feature_flag_evaluations.FlagValue -> posthog.types.FlagValue
+alias posthog.feature_flag_evaluations.UnresolvedFlagReason -> posthog.types.UnresolvedFlagReason
 alias posthog.feature_flags.FlagValue -> posthog.types.FlagValue
+alias posthog.feature_flags.UnresolvedFlagReason -> posthog.types.UnresolvedFlagReason
 alias posthog.feature_flags.convert_to_datetime_aware -> posthog.utils.convert_to_datetime_aware
 alias posthog.feature_flags.is_valid_regex -> posthog.utils.is_valid_regex
 alias posthog.feature_flags.utils -> posthog.utils
@@ -905,14 +909,17 @@ attribute posthog.exception_utils.VariableSizeLimiter.current_size = 0
 attribute posthog.exception_utils.VariableSizeLimiter.max_size = max_size
 attribute posthog.exception_utils.epoch = datetime(1970, 1, 1)
 attribute posthog.feature_flag_evaluations.FeatureFlagEvaluations.keys: List[str]
+attribute posthog.feature_flag_evaluations.FeatureFlagEvaluations.unresolved_flags: Mapping[str, UnresolvedFlagReason]
 attribute posthog.feature_flags.ConditionMatch.MATCH = 'match'
 attribute posthog.feature_flags.ConditionMatch.NO_MATCH = 'no_match'
 attribute posthog.feature_flags.ConditionMatch.OUT_OF_ROLLOUT_BOUND = 'out_of_rollout_bound'
 attribute posthog.feature_flags.DATE_OPERATORS = ('is_date_before', 'is_date_after')
 attribute posthog.feature_flags.EQUALITY_OPERATORS = ('exact', 'is_not', 'is_set', 'is_not_set')
+attribute posthog.feature_flags.InconclusiveMatchError.reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
 attribute posthog.feature_flags.NONE_VALUES_ALLOWED_OPERATORS = ['is_not']
 attribute posthog.feature_flags.NUMERIC_OPERATORS = ('gt', 'gte', 'lt', 'lte')
 attribute posthog.feature_flags.PROPERTY_OPERATORS = EQUALITY_OPERATORS + STRING_OPERATORS + NUMERIC_OPERATORS + DATE_OPERATORS + SEMVER_OPERATORS
+attribute posthog.feature_flags.RequiresServerEvaluation.reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
 attribute posthog.feature_flags.SEMVER_COMPARISON_OPERATORS = ('semver_eq', 'semver_neq', 'semver_gt', 'semver_gte', 'semver_lt', 'semver_lte')
 attribute posthog.feature_flags.SEMVER_OPERATORS = SEMVER_COMPARISON_OPERATORS + SEMVER_RANGE_OPERATORS
 attribute posthog.feature_flags.SEMVER_RANGE_OPERATORS = ('semver_tilde', 'semver_caret', 'semver_wildcard')
@@ -1128,6 +1135,7 @@ attribute posthog.types.FeatureFlag.variant: Optional[str]
 attribute posthog.types.FeatureFlagError.CONNECTION_ERROR = 'connection_error'
 attribute posthog.types.FeatureFlagError.ERRORS_WHILE_COMPUTING = 'errors_while_computing_flags'
 attribute posthog.types.FeatureFlagError.FLAG_MISSING = 'flag_missing'
+attribute posthog.types.FeatureFlagError.LOCAL_EVALUATION_INCONCLUSIVE = 'local_evaluation_inconclusive'
 attribute posthog.types.FeatureFlagError.QUOTA_LIMITED = 'quota_limited'
 attribute posthog.types.FeatureFlagError.TIMEOUT = 'timeout'
 attribute posthog.types.FeatureFlagError.UNKNOWN_ERROR = 'unknown_error'
@@ -1162,6 +1170,10 @@ attribute posthog.types.SendFeatureFlagsOptions.group_properties: Optional[dict[
 attribute posthog.types.SendFeatureFlagsOptions.only_evaluate_locally: Optional[bool]
 attribute posthog.types.SendFeatureFlagsOptions.person_properties: Optional[dict[str, Any]]
 attribute posthog.types.SendFeatureFlagsOptions.should_send: bool
+attribute posthog.types.UnresolvedFlagReason.EXPERIENCE_CONTINUITY = 'experience_continuity'
+attribute posthog.types.UnresolvedFlagReason.MISSING_CONTEXT = 'missing_context'
+attribute posthog.types.UnresolvedFlagReason.UNRESOLVED_DEPENDENCY = 'unresolved_dependency'
+attribute posthog.types.UnresolvedFlagReason.UNSUPPORTED_DEFINITION = 'unsupported_definition'
 attribute posthog.utils.CACHE_KEY_PREFIX = 'posthog:flags:'
 attribute posthog.utils.CACHE_MAX_SIZE = 10000
 attribute posthog.utils.CACHE_STALE_TTL = 3600
@@ -1289,10 +1301,10 @@ class posthog.contexts.ContextScope(parent=None, fresh: bool = False, capture_ex
 class posthog.exception_capture.ExceptionCapture(client: Client, rate_limiting_enabled=False, bucket_size=DEFAULT_BUCKET_SIZE, refill_rate=DEFAULT_REFILL_RATE, refill_interval_seconds=DEFAULT_REFILL_INTERVAL_SECONDS)
 class posthog.exception_utils.AnnotatedValue(value, metadata)
 class posthog.exception_utils.VariableSizeLimiter(max_size=DEFAULT_TOTAL_VARIABLES_SIZE_LIMIT)
-class posthog.feature_flag_evaluations.FeatureFlagEvaluations(host: _FeatureFlagEvaluationsHost, distinct_id: str, flags: Dict[str, _EvaluatedFlagRecord], groups: Optional[Mapping[str, Union[str, int]]] = None, disable_geoip: Optional[bool] = None, request_id: Optional[str] = None, evaluated_at: Optional[int] = None, errors_while_computing: bool = False, quota_limited: bool = False, minimal_flag_called_events: bool = False, accessed: Optional[Set[str]] = None)
+class posthog.feature_flag_evaluations.FeatureFlagEvaluations(host: _FeatureFlagEvaluationsHost, distinct_id: str, flags: Dict[str, _EvaluatedFlagRecord], groups: Optional[Mapping[str, Union[str, int]]] = None, disable_geoip: Optional[bool] = None, request_id: Optional[str] = None, evaluated_at: Optional[int] = None, errors_while_computing: bool = False, quota_limited: bool = False, minimal_flag_called_events: bool = False, accessed: Optional[Set[str]] = None, unresolved_flags: Optional[Mapping[str, UnresolvedFlagReason]] = None)
 class posthog.feature_flags.ConditionMatch 
-class posthog.feature_flags.InconclusiveMatchError 
-class posthog.feature_flags.RequiresServerEvaluation 
+class posthog.feature_flags.InconclusiveMatchError(*args, reason: Optional[UnresolvedFlagReason] = None)
+class posthog.feature_flags.RequiresServerEvaluation(*args, reason: Optional[UnresolvedFlagReason] = None)
 class posthog.flag_definition_cache.FlagDefinitionCacheData 
 class posthog.flag_definition_cache.FlagDefinitionCacheProvider 
 class posthog.integrations.asgi.PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: Optional[bool] = None, *, capture_tracing_headers: Optional[bool] = None)
@@ -1333,6 +1345,7 @@ class posthog.types.FlagsAndPayloads
 class posthog.types.FlagsResponse 
 class posthog.types.LegacyFlagMetadata(payload: Any)
 class posthog.types.SendFeatureFlagsOptions 
+class posthog.types.UnresolvedFlagReason 
 class posthog.utils.FlagCache(max_size=CACHE_MAX_SIZE, default_ttl=CACHE_TTL)
 class posthog.utils.FlagCacheEntry(flag_result, flag_definition_version, timestamp=None)
 class posthog.utils.RedisFlagCache(redis_client, default_ttl=CACHE_TTL, stale_ttl=CACHE_STALE_TTL, key_prefix=CACHE_KEY_PREFIX)

From 91d3188bb4dbf5ed8e59165f0dbd62836a05d384 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 21:22:04 +0000
Subject: [PATCH 127/245] chore: Release v7.79.0 [skip ci]

---
 .sampo/changesets/unresolved-local-flags.md | 13 -------------
 openfeature-provider/CHANGELOG.md           |  6 ++++++
 openfeature-provider/pyproject.toml         |  2 +-
 posthog/CHANGELOG.md                        | 14 ++++++++++++++
 posthog/version.py                          |  2 +-
 pyproject.toml                              |  2 +-
 uv.lock                                     |  4 ++--
 7 files changed, 25 insertions(+), 18 deletions(-)
 delete mode 100644 .sampo/changesets/unresolved-local-flags.md

diff --git a/.sampo/changesets/unresolved-local-flags.md b/.sampo/changesets/unresolved-local-flags.md
deleted file mode 100644
index 135465dc9..000000000
--- a/.sampo/changesets/unresolved-local-flags.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-pypi/posthog: minor
----
-
-Report flags that local evaluation could not resolve on `evaluate_flags()` snapshots. `FeatureFlagEvaluations.unresolved_flags` maps each such flag to an `UnresolvedFlagReason` (`experience_continuity`, `unsupported_definition`, `unresolved_dependency` or `missing_context`), and reading one reports the `local_evaluation_inconclusive` error instead of `flag_missing`. When definitions load, log one warning per flag that local evaluation can never resolve (experience continuity, a static cohort, an unknown operator, a malformed value, or a missing or circular flag dependency), and again only when its definition changes. `AsyncClient` evaluates only remotely, so its snapshots have no unresolved flags.
-
-Behavior changes:
-
-- A condition with a filter that local evaluation can't check and a filter that does not match now resolves locally as no match. Before, such a flag fell back to a remote request, or stayed unresolved with `only_evaluate_locally=True`.
-- An inactive flag with experience continuity enabled now resolves to `false` locally instead of falling back to a remote request.
-- A flag that depends on a flag with experience continuity enabled is no longer evaluated locally. It falls back to a remote request, or stays unresolved with `only_evaluate_locally=True`.
-- On `$feature_flag_called` events from an `evaluate_flags()` snapshot, `$feature_flag_error` is now `local_evaluation_inconclusive` instead of `flag_missing` for a flag that has a loaded definition but that local evaluation could not resolve.
-- `get_all_flags()`, `get_all_flags_and_payloads()` and `evaluate_flags()` no longer log an error with a traceback when a flag needs the server (for example, a static cohort). They fall back to a remote request without logging, as `get_feature_flag()` already did.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 8ab8f1da8..b06b99036 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.130 — 2026-10-28
+
+### Patch changes
+
+- Updated dependencies: posthog@7.79.0
+
 ## 0.1.129 — 2026-10-28
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 36422e109..fd4301834 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.129"
+version = "0.1.130"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index c8eb695ac..063d59e0c 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,19 @@
 # posthog
 
+## 7.79.0 — 2026-10-28
+
+### Minor changes
+
+- [bb2b9d6](https://github.com/posthog/posthog-python/commit/bb2b9d6bddd250f6dcf03be565af8ba94694e5db) Report flags that local evaluation could not resolve on `evaluate_flags()` snapshots. `FeatureFlagEvaluations.unresolved_flags` maps each such flag to an `UnresolvedFlagReason` (`experience_continuity`, `unsupported_definition`, `unresolved_dependency` or `missing_context`), and reading one reports the `local_evaluation_inconclusive` error instead of `flag_missing`. When definitions load, log one warning per flag that local evaluation can never resolve (experience continuity, a static cohort, an unknown operator, a malformed value, or a missing or circular flag dependency), and again only when its definition changes. `AsyncClient` evaluates only remotely, so its snapshots have no unresolved flags.
+  
+  Behavior changes:
+  
+  - A condition with a filter that local evaluation can't check and a filter that does not match now resolves locally as no match. Before, such a flag fell back to a remote request, or stayed unresolved with `only_evaluate_locally=True`.
+  - An inactive flag with experience continuity enabled now resolves to `false` locally instead of falling back to a remote request.
+  - A flag that depends on a flag with experience continuity enabled is no longer evaluated locally. It falls back to a remote request, or stays unresolved with `only_evaluate_locally=True`.
+  - On `$feature_flag_called` events from an `evaluate_flags()` snapshot, `$feature_flag_error` is now `local_evaluation_inconclusive` instead of `flag_missing` for a flag that has a loaded definition but that local evaluation could not resolve.
+  - `get_all_flags()`, `get_all_flags_and_payloads()` and `evaluate_flags()` no longer log an error with a traceback when a flag needs the server (for example, a static cohort). They fall back to a remote request without logging, as `get_feature_flag()` already did. — Thanks @gustavohstrassburger!
+
 ## 7.78.0 — 2026-10-28
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index a1744501a..c6c3571ef 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.78.0"
+VERSION = "7.79.0"
diff --git a/pyproject.toml b/pyproject.toml
index ce79329d0..bab09689c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.78.0"
+version = "7.79.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 297ff4dc6..a0f072074 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.129"
+version = "0.1.130"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3054,7 +3054,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.78.0"
+version = "7.79.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 130f5a1e8508a7a9005bf46658ff8d43b7457232 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 28 Oct 2026 21:22:09 +0000
Subject: [PATCH 128/245] Update generated references

---
 .../posthog-python-references-7.79.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    6 +-
 2 files changed, 3551 insertions(+), 3 deletions(-)
 create mode 100644 references/posthog-python-references-7.79.0.json

diff --git a/references/posthog-python-references-7.79.0.json b/references/posthog-python-references-7.79.0.json
new file mode 100644
index 000000000..a58eca355
--- /dev/null
+++ b/references/posthog-python-references-7.79.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.79.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 66be86ee2..a58eca355 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.78.0",
+    "version": "7.79.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -871,7 +871,7 @@
             },
             {
               "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
               "isOptional": false,
               "type": "bool"
             },
@@ -2352,7 +2352,7 @@
             },
             {
               "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
               "isOptional": false,
               "type": "bool"
             },

From febb3ed2f1584e68c05c73625becbdd18fe5f944 Mon Sep 17 00:00:00 2001
From: Daniel Visca <daniel.v@posthog.com>
Date: Thu, 29 Oct 2026 06:27:02 -0400
Subject: [PATCH 129/245] feat(metrics): metrics autocapture for HTTP, database
 and runtime metrics (#992)

* feat(metrics): add metrics autocapture for HTTP, database and runtime metrics

`metrics={"autocapture": True}` starts the installed OpenTelemetry instrumentors with private meter and tracer providers and exports to `/i/v1/metrics`. The packages come from the new `posthog[metrics]` extra.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: ef9b57c2-47ff-47e6-a509-8873ffe1fab4

* test: check concurrent LangChain traces without assuming order

Generated-By: PostHog Desktop
Task-Id: c0218209-575c-46f0-a201-d0c831e38096

* fix(metrics): address autocapture review findings

- Honour send=False in the autocapture export gate.
- Strip trailing slashes from the host before building the metrics endpoint.
- Set OTEL_SEMCONV_STABILITY_OPT_IN only while the instrumentors load, then
  restore the process environment.
- Limit each synchronous instrument to 2000 attribute sets; send the rest to
  an otel.metric.overflow series, so user-supplied hosts cannot grow the SDK cache.
- After fork, replace the module lock and point the runtime instrumentor at
  the child process.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: 10838116-90e2-4d23-af38-8099d7887d07

* fix(metrics): keep app-owned instrumentors intact and hold ownership through shutdown

- Skip an instrumentor whose singleton the app already instrumented before creating it. Creating it ran __init__ again and reset the app's system metrics config.
- Uninstrument while the module lock is held, so a client that starts during shutdown cannot skip libraries that are about to be uninstrumented. The last export still runs outside the lock.
- Correct the module docstring: an app cannot instrument a library again with its own OpenTelemetry setup while autocapture instruments it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): use stable HTTP metric names when another instrumentor read the opt-in first

OpenTelemetry reads OTEL_SEMCONV_STABILITY_OPT_IN once per process. If any instrumentor ran before the client started, autocapture sent http.client.duration (ms) and not http.client.request.duration (s). When the app has not set an opt-in, autocapture now sets the HTTP mode to stable after initialisation, so the names do not depend on import order.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): address the second review round of metrics autocapture

- Do not send the app's OTEL_EXPORTER_OTLP_* settings (other vendors' headers, endpoint, TLS files) to PostHog: the private exporter is built without them.
- Give HTTP instrumentors a no-op tracer, so app requests no longer carry an unsampled traceparent that makes downstream services drop their traces.
- Record nothing while the client is disabled, and apply metrics.before_send to autocaptured measurements and runtime observations (value and attributes, or drop).
- Exclude the PostHog host in any case and with or without its default port, escape commas, keep OTEL_PYTHON_*_EXCLUDED_URLS, and apply the exclusion to httpx.
- Reset the reader's export lock in a forked child, export autocaptured metrics on Client.flush() and within the client's exit budget (no 10 s exit wait), roll back on a failed start, and uninstrument and reinstrument Flask apps across a restart.
- Start autocapture on a later module-level setup(), once per client.
- Validate flush_interval like client.metrics, use the same resource as client.metrics, keep the first word of db.operation.name, and raise the minimum OpenTelemetry versions to the first ones with the runtime metric names.
- Rename the module to posthog/_metrics_autocapture.py to keep internals out of the public API.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): keep app middleware on shutdown, stop context propagation, and fix fork and flush issues

- Flask: shutdown uninstruments an app only when its WSGI app is still the one the instrumentation set. uninstrument_app() would otherwise remove middleware the app added later, such as authentication. Instrumentation left in place records nothing after shutdown.
- Do not propagate context: the instrumentors that autocapture starts no longer inject trace context or baggage into outgoing requests, including a trace extracted from an incoming request.
- Keep the attributes that a database span starts with (asyncpg passes db.system then).
- Export the last window at exit in sync mode.
- Replace the metrics SDK collection and aggregation locks in a forked child, where a parent thread could hold them.
- Use one flush thread at a time, with one follow-up export for calls made during a flush.
- Run metrics.before_send as an SDK callback, so a flush() it calls is deferred and cannot deadlock the collection.
- Raise the minimum OpenTelemetry instrumentation version to 0.60b0, the first in which the httpx instrumentor excludes URLs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): do not let the Django instrumentor configure empty settings

Without configured settings, DjangoInstrumentor calls settings.configure() with empty settings, so an app that configures its settings in code after creating the client fails with "Settings already configured". Autocapture now starts the Django instrumentor only when the settings are configured, as in AppConfig.ready().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): drop raw URL attributes, normalize hook attributes, and stop flush loops from hooks

- Never record raw URLs and paths (url.full, http.url, http.target, ...), client addresses, user agents or captured headers. Instrumentors such as Tornado put them on metrics, and they can hold tokens and emails. Routes stay.
- Keep only valid OpenTelemetry attribute values, with sequences as tuples, before and after metrics.before_send. SDK 1.39 raised TypeError for a list value inside the app's request. Recording errors no longer reach the instrumented call.
- A flush() called from a metrics before_send hook still flushes events and spans, but does not start another autocapture export, which ran the hook again without end.
- Each flush request waits only for the first export that starts after it, not for later exports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: a129c1a0-57e3-4370-a4df-6542e710ab75

* fix(metrics): isolate exporter settings and autocapture lifecycle state

* fix(metrics): address remaining autocapture lifecycle feedback

---------

Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .sampo/changesets/metrics-autocapture.md    |   13 +
 posthog/__init__.py                         |   11 +-
 posthog/_metrics_autocapture.py             | 1312 ++++++++++++++
 posthog/client.py                           |  158 +-
 posthog/metrics_capture.py                  |   45 +-
 posthog/test/ai/langchain/test_callbacks.py |   29 +-
 posthog/test/test_metrics_autocapture.py    | 1716 +++++++++++++++++++
 pyproject.toml                              |   21 +
 uv.lock                                     |  206 ++-
 9 files changed, 3474 insertions(+), 37 deletions(-)
 create mode 100644 .sampo/changesets/metrics-autocapture.md
 create mode 100644 posthog/_metrics_autocapture.py
 create mode 100644 posthog/test/test_metrics_autocapture.py

diff --git a/.sampo/changesets/metrics-autocapture.md b/.sampo/changesets/metrics-autocapture.md
new file mode 100644
index 000000000..d562f8862
--- /dev/null
+++ b/.sampo/changesets/metrics-autocapture.md
@@ -0,0 +1,13 @@
+---
+pypi/posthog: minor
+---
+
+Add `metrics={"autocapture": True}` (alpha): HTTP, database and runtime metrics from the official OpenTelemetry instrumentations, with no instrumentation code. Install `posthog[metrics]` and run `opentelemetry-bootstrap -a install` to add the instrumentors for your libraries. Create the client before your web app (Django: in `AppConfig.ready()`): apps created earlier are not measured. For Flask, use module lookup as below, or import the `Flask` class only after the client starts; an earlier `from flask import Flask` alias is not instrumented. Already-served Flask apps are not re-instrumented after shutdown; create a new app for a replacement client. Autocapture does not start when the app already set up OpenTelemetry; export those metrics to PostHog instead. Raw URLs and paths, client addresses, user agents and captured headers are never recorded. `metrics.before_send` also applies to autocaptured measurements: it can change their value and attributes, or drop them.
+
+```python
+import flask
+from posthog import Posthog
+
+client = Posthog("phc_...", metrics={"autocapture": True})
+app = flask.Flask(__name__)
+```
diff --git a/posthog/__init__.py b/posthog/__init__.py
index a4c3f3678..d9f6d174f 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -342,7 +342,14 @@ def get_tags() -> Dict[str, Any]:
     metrics: Config dict for the ``client.metrics`` API (``service_name``,
         ``service_version``, ``environment``, ``flush_interval``, ...). Applied
         when ``setup()`` builds the global client, or on a later ``setup()``
-        call if the metrics API hasn't been used yet.
+        call if the metrics API hasn't been used yet. ``autocapture`` (alpha,
+        ``True`` or ``{"http": ..., "db": ..., "runtime": ...}``) starts HTTP,
+        database and runtime metrics from the OpenTelemetry instrumentations
+        when ``setup()`` runs with it; call ``setup()`` before the web app is
+        created, because apps created earlier are not measured. For Flask,
+        use ``flask.Flask(...)`` after setup, or import the ``Flask`` class only
+        after setup. Already-served Flask apps are not re-instrumented after
+        shutdown; create a new app for a replacement client.
     traces: Config dict for distributed tracing: ``service_name``,
         ``service_version``, ``environment``, ``resource_attributes``,
         ``flush_interval`` (5 s), ``max_queue_size`` (2048),
@@ -1479,6 +1486,8 @@ def setup() -> Client:
     # already forced setup()) still applies until the metrics API is first used.
     if default_client._metrics is None:
         default_client._metrics_config = metrics
+    # Autocapture is not lazy, so a late `metrics` option starts it here.
+    default_client._start_metrics_autocapture_once(metrics)
     # traces=None means off, so the module option applies only where the client
     # has none; False is the latch of an init that failed and stays off.
     if traces is not None and default_client._traces_config is None:
diff --git a/posthog/_metrics_autocapture.py b/posthog/_metrics_autocapture.py
new file mode 100644
index 000000000..4771f2d5a
--- /dev/null
+++ b/posthog/_metrics_autocapture.py
@@ -0,0 +1,1312 @@
+"""Metrics autocapture (``metrics={"autocapture": True}``) — alpha.
+
+HTTP, database and runtime metrics from the official OpenTelemetry
+instrumentations, exported to PostHog's ``/i/v1/metrics`` with no
+instrumentation code in the app.
+
+The OpenTelemetry packages come from the ``posthog[metrics]`` extra and are
+imported only when autocapture starts. Library instrumentors (requests, Django,
+psycopg, ...) are found through the ``opentelemetry_instrumentor`` entry points,
+the same way ``opentelemetry-instrument`` finds them. An instrumentor changes the
+library classes when it starts, so objects created before that, such as a Flask
+or FastAPI app, are not measured: create the client before the web app. For Flask,
+use ``import flask`` and construct ``flask.Flask(...)`` after starting the client,
+or import the ``Flask`` class only afterward. An already-served Flask app is not
+instrumented again after shutdown; create a new app for a replacement client.
+Django is instrumented only when its settings are configured, as in ``AppConfig.ready()``.
+
+The meter and tracer providers are private: nothing is set on the OpenTelemetry
+globals, and the app's ``OTEL_EXPORTER_OTLP_*`` settings are not used. The
+library instrumentors are process-wide singletons, though, so an app cannot
+instrument a library again with its own OpenTelemetry setup while autocapture
+instruments it. Apps with their own OpenTelemetry instrumentation should export
+their metrics to PostHog and not turn on autocapture.
+
+Raw URLs and paths, client addresses, user agents and captured headers are never
+recorded; routes (such as ``/users/{id}``) are. Spans are only used to derive
+database metrics and are never exported. The HTTP
+instrumentors get no tracer, and the instrumentors that autocapture starts do not
+propagate context, so no trace context or baggage goes to other services.
+"""
+
+import importlib
+import logging
+import os
+import re
+import sys
+import threading
+import weakref
+from contextlib import contextmanager
+from importlib.metadata import entry_points
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+from urllib.parse import urlsplit
+
+from .version import VERSION
+
+try:
+    from opentelemetry.sdk.trace import SpanProcessor as _SpanProcessorBase
+except ImportError:  # pragma: no cover - the processor is only built once OTel imports
+    _SpanProcessorBase = object
+
+log = logging.getLogger("posthog")
+
+_import_module = importlib.import_module
+
+_INSTALL_HINT = 'pip install "posthog[metrics]" && opentelemetry-bootstrap -a install'
+
+_HTTP_CLIENT_INSTRUMENTORS = (
+    "requests",
+    "urllib",
+    "urllib3",
+    "httpx",
+    "aiohttp-client",
+)
+_HTTP_SERVER_INSTRUMENTORS = (
+    "django",
+    "flask",
+    "fastapi",
+    "starlette",
+    "falcon",
+    "pyramid",
+    "tornado",
+    "aiohttp-server",
+)
+_DB_DRIVER_INSTRUMENTORS = (
+    "psycopg2",
+    "psycopg",
+    "asyncpg",
+    "pymysql",
+    "mysql",
+    "mysqlclient",
+    "sqlite3",
+    "pymongo",
+    "redis",
+    "pymssql",
+    "cassandra",
+)
+# SQLAlchemy adds connection pool metrics. Its spans wrap a driver span, so they
+# are not turned into operation metrics: that would count one query twice.
+_DB_INSTRUMENTORS = _DB_DRIVER_INSTRUMENTORS + ("sqlalchemy",)
+_DERIVED_DB_METRIC_SCOPES = frozenset(
+    f"opentelemetry.instrumentation.{name}" for name in _DB_DRIVER_INSTRUMENTORS
+)
+
+# Process-level metrics only; the host-wide system.* metrics are left out.
+_RUNTIME_CONFIG: Dict[str, Optional[List[str]]] = {
+    "process.cpu.time": ["user", "system"],
+    "process.cpu.utilization": ["user", "system"],
+    "process.memory.usage": None,
+    "process.memory.virtual": None,
+    "process.open_file_descriptor.count": None,
+    "process.thread.count": None,
+    "process.context_switches": ["involuntary", "voluntary"],
+    "cpython.gc.collections": None,
+    "cpython.gc.collected_objects": None,
+    "cpython.gc.uncollectable_objects": None,
+}
+
+_DB_OPERATION_DURATION = "db.client.operation.duration"
+# OpenTelemetry semantic convention advice for `db.client.operation.duration`.
+_DB_DURATION_BUCKETS = [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10]
+# The leading keyword (`SELECT`, `GET`) is bounded; the rest of a statement is not.
+_STATEMENT_KEYWORD = re.compile(r"^\s*([A-Za-z]{2,20})\b")
+
+# The OpenTelemetry SDK keeps every attribute set it has seen, also with delta
+# temporality, and has no limit of its own. Some attributes, such as the
+# `server.address` of an outgoing request, can come from user input. So each
+# instrument keeps at most this many attribute sets. Other measurements go to one
+# overflow series, as the OpenTelemetry cardinality limit specifies.
+_MAX_ATTRIBUTE_SETS = 2000
+_OVERFLOW_ATTRIBUTES = {"otel.metric.overflow": True}
+
+# Attributes that some instrumentors put on metrics, such as Tornado's raw
+# `http.target` and `http.url`. Paths and URLs can hold tokens and emails, and
+# client addresses and user agents identify users. They are never recorded.
+_UNSAFE_ATTRIBUTES = frozenset(
+    {
+        "http.url",
+        "http.target",
+        "url.full",
+        "url.path",
+        "url.query",
+        "http.client_ip",
+        "client.address",
+        "net.peer.ip",
+        "net.sock.peer.addr",
+        "http.user_agent",
+        "user_agent.original",
+    }
+)
+_UNSAFE_ATTRIBUTE_PREFIXES = ("http.request.header.", "http.response.header.")
+_ATTRIBUTE_VALUE_TYPES = (str, bool, int, float)
+
+_SEMCONV_OPT_IN = "OTEL_SEMCONV_STABILITY_OPT_IN"
+_EXPORT_TIMEOUT_SECONDS = 10.0
+_DEFAULT_PORTS = {"http": 80, "https": 443}
+
+# The `metrics.before_send` sample type of each instrument kind.
+_SAMPLE_TYPES = {
+    "create_counter": "count",
+    "create_up_down_counter": "count",
+    "create_histogram": "histogram",
+    "create_gauge": "gauge",
+    "create_observable_counter": "count",
+    "create_observable_up_down_counter": "count",
+    "create_observable_gauge": "gauge",
+}
+
+_lock = threading.Lock()
+_active: Optional["MetricsAutocapture"] = None
+_warned_about_missing_packages = False
+# Flask apps created while autocapture runs. FlaskInstrumentor.uninstrument()
+# restores only the Flask class, so shutdown uninstruments these apps. A later
+# autocapture can instrument them again only before their first request.
+_flask_apps: "weakref.WeakSet[Any]" = weakref.WeakSet()
+# The `inject` functions that autocapture replaced in instrumentor modules,
+# by module name.
+_replaced_injects: Dict[str, Any] = {}
+_replaced_aiohttp_trace_config: Optional[Tuple[Callable, Callable]] = None
+
+
+def _always_enabled() -> bool:
+    return True
+
+
+def _apply_before_send(
+    before_send: Callable,
+    name: str,
+    metric_type: str,
+    unit: str,
+    value: Any,
+    attributes: Any,
+) -> Optional[Tuple[Any, Any]]:
+    """Runs the ``metrics.before_send`` hook on one measurement, like the
+    ``client.metrics`` API does. Returns the value and attributes to record, or
+    ``None`` to drop it. An instrument's name, type and unit are fixed, so the
+    hook can change only the value and the attributes."""
+    sample = {
+        "name": name,
+        "type": metric_type,
+        "value": value,
+        "unit": unit,
+        "attributes": dict(attributes) if attributes else {},
+    }
+    try:
+        filtered = before_send(sample)
+    except Exception as e:
+        log.error("Error in metrics before_send: %s", e)
+        return None
+    if not filtered:
+        return None
+    if not isinstance(filtered, dict):
+        log.warning(
+            "Dropping metric: before_send must return the sample dict or a falsy value"
+        )
+        return None
+    value = filtered.get("value")
+    attributes = filtered.get("attributes")
+    if (
+        not isinstance(value, (int, float))
+        or isinstance(value, bool)
+        or not isinstance(attributes, (dict, type(None)))
+    ):
+        log.warning(
+            "Dropping metric '%s': before_send returned an invalid value or attributes",
+            name,
+        )
+        return None
+    return value, attributes
+
+
+def _clean_attributes(attributes: Any) -> Any:
+    """Removes the unsafe attributes, and keeps only valid OpenTelemetry values,
+    with sequences as tuples. Some OpenTelemetry versions raise for a list value,
+    and `before_send` can return any value."""
+    if not attributes:
+        return attributes
+    try:
+        items = list(attributes.items())
+    except (AttributeError, TypeError):
+        return None
+    cleaned: Dict[str, Any] = {}
+    for key, value in items:
+        if (
+            not isinstance(key, str)
+            or key in _UNSAFE_ATTRIBUTES
+            or key.startswith(_UNSAFE_ATTRIBUTE_PREFIXES)
+        ):
+            continue
+        if isinstance(value, _ATTRIBUTE_VALUE_TYPES):
+            cleaned[key] = value
+        elif isinstance(value, (list, tuple)) and all(
+            isinstance(item, _ATTRIBUTE_VALUE_TYPES) for item in value
+        ):
+            cleaned[key] = tuple(value)
+    return cleaned
+
+
+def _instrument_name_and_unit(args: tuple, kwargs: dict, unit_index: int):
+    name = kwargs.get("name", args[0] if args else "")
+    unit = kwargs.get("unit", args[unit_index] if len(args) > unit_index else "")
+    return name, unit
+
+
+class _BoundedInstrument:
+    """A synchronous instrument that records only while autocapture is enabled,
+    applies ``before_send``, and sends new attribute sets to the overflow series
+    once it has seen ``limit`` of them."""
+
+    def __init__(
+        self,
+        instrument: Any,
+        limit: int,
+        is_enabled: Callable[[], bool] = _always_enabled,
+        before_send: Optional[Callable] = None,
+        name: str = "",
+        metric_type: str = "",
+        unit: str = "",
+        stopped: Optional[threading.Event] = None,
+    ):
+        self._instrument = instrument
+        self._stopped = stopped
+        self._limit = limit
+        self._is_enabled = is_enabled
+        self._before_send = before_send
+        self._name = name
+        self._metric_type = metric_type
+        self._unit = unit
+        # No lock: a race can only go over the limit by the number of threads.
+        self._seen: set = set()
+
+    def _bounded(self, attributes: Any) -> Any:
+        try:
+            key = frozenset(attributes.items()) if attributes else frozenset()
+        except (AttributeError, TypeError):
+            return attributes
+        if key in self._seen:
+            return attributes
+        if len(self._seen) < self._limit:
+            self._seen.add(key)
+            return attributes
+        return _OVERFLOW_ATTRIBUTES
+
+    def _record(self, method: str, amount, attributes, args, kwargs):
+        # Like `client.metrics`, nothing is recorded while the client is disabled,
+        # so that period is not exported once the client is enabled again.
+        # Instrumentation that shutdown leaves in place records nothing more.
+        if (
+            self._stopped is not None and self._stopped.is_set()
+        ) or not self._is_enabled():
+            return None
+        attributes = _clean_attributes(attributes)
+        if self._before_send is not None:
+            measurement = _apply_before_send(
+                self._before_send,
+                self._name,
+                self._metric_type,
+                self._unit,
+                amount,
+                attributes,
+            )
+            if measurement is None:
+                return None
+            amount, attributes = measurement
+            attributes = _clean_attributes(attributes)
+        # This runs in the instrumented call, such as the app's HTTP request.
+        try:
+            return getattr(self._instrument, method)(
+                amount, self._bounded(attributes), *args, **kwargs
+            )
+        except Exception:
+            log.debug(
+                "Metrics autocapture failed to record %s", self._name, exc_info=True
+            )
+            return None
+
+    def add(self, amount, attributes=None, *args, **kwargs):
+        return self._record("add", amount, attributes, args, kwargs)
+
+    def record(self, amount, attributes=None, *args, **kwargs):
+        return self._record("record", amount, attributes, args, kwargs)
+
+    def set(self, amount, attributes=None, *args, **kwargs):
+        return self._record("set", amount, attributes, args, kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self._instrument, name)
+
+
+class _BoundedMeter:
+    def __init__(
+        self,
+        meter: Any,
+        limit: int,
+        instruments: Dict[Any, _BoundedInstrument],
+        is_enabled: Callable[[], bool] = _always_enabled,
+        before_send: Optional[Callable] = None,
+        stopped: Optional[threading.Event] = None,
+    ):
+        self._meter = meter
+        self._limit = limit
+        self._instruments = instruments
+        self._is_enabled = is_enabled
+        self._before_send = before_send
+        self._stopped = stopped
+
+    def _bounded(self, factory: str, args, kwargs) -> _BoundedInstrument:
+        name, unit = _instrument_name_and_unit(args, kwargs, unit_index=1)
+        instrument = getattr(self._meter, factory)(*args, **kwargs)
+        if instrument in self._instruments:
+            return self._instruments[instrument]
+        return self._instruments.setdefault(
+            instrument,
+            _BoundedInstrument(
+                instrument,
+                self._limit,
+                self._is_enabled,
+                self._before_send,
+                name,
+                _SAMPLE_TYPES[factory],
+                unit,
+                self._stopped,
+            ),
+        )
+
+    def _observable(self, factory: str, args, kwargs):
+        # Observable instruments report from bounded callbacks (runtime metrics),
+        # so only the enabled check and `before_send` apply to them. They still
+        # report in the last collection of shutdown.
+        name, unit = _instrument_name_and_unit(args, kwargs, unit_index=2)
+        args = list(args)
+        if len(args) > 1:
+            args[1] = self._gated_callbacks(args[1], name, _SAMPLE_TYPES[factory], unit)
+        elif "callbacks" in kwargs:
+            kwargs["callbacks"] = self._gated_callbacks(
+                kwargs["callbacks"], name, _SAMPLE_TYPES[factory], unit
+            )
+        return getattr(self._meter, factory)(*args, **kwargs)
+
+    def _gated_callbacks(self, callbacks, name: str, metric_type: str, unit: str):
+        if not callbacks:
+            return callbacks
+        is_enabled, before_send = self._is_enabled, self._before_send
+        observation_class = _import_module("opentelemetry.metrics").Observation
+
+        def gated(callback):
+            def observe(options):
+                if not is_enabled():
+                    return []
+                observations = callback(options)
+                if before_send is None:
+                    return observations
+                kept = []
+                for observation in observations or ():
+                    measurement = _apply_before_send(
+                        before_send,
+                        name,
+                        metric_type,
+                        unit,
+                        observation.value,
+                        observation.attributes,
+                    )
+                    if measurement is not None:
+                        value, attributes = measurement
+                        kept.append(
+                            observation_class(value, _clean_attributes(attributes))
+                        )
+                return kept
+
+            return observe
+
+        # Generator objects are also valid callbacks; they are passed on as they are.
+        return [
+            gated(callback) if callable(callback) else callback
+            for callback in callbacks
+        ]
+
+    def create_counter(self, *args, **kwargs):
+        return self._bounded("create_counter", args, kwargs)
+
+    def create_up_down_counter(self, *args, **kwargs):
+        return self._bounded("create_up_down_counter", args, kwargs)
+
+    def create_histogram(self, *args, **kwargs):
+        return self._bounded("create_histogram", args, kwargs)
+
+    def create_gauge(self, *args, **kwargs):
+        return self._bounded("create_gauge", args, kwargs)
+
+    def create_observable_counter(self, *args, **kwargs):
+        return self._observable("create_observable_counter", args, kwargs)
+
+    def create_observable_up_down_counter(self, *args, **kwargs):
+        return self._observable("create_observable_up_down_counter", args, kwargs)
+
+    def create_observable_gauge(self, *args, **kwargs):
+        return self._observable("create_observable_gauge", args, kwargs)
+
+    def __getattr__(self, name):
+        return getattr(self._meter, name)
+
+
+class _BoundedMeterProvider:
+    """The meter provider given to the instrumentors. Its instruments record only
+    while autocapture is enabled, apply ``before_send``, and limit the number of
+    attribute sets of each synchronous instrument."""
+
+    def __init__(
+        self,
+        meter_provider: Any,
+        limit: int,
+        is_enabled: Callable[[], bool] = _always_enabled,
+        before_send: Optional[Callable] = None,
+        stopped: Optional[threading.Event] = None,
+    ):
+        self._meter_provider = meter_provider
+        self._instruments: Dict[Any, _BoundedInstrument] = {}
+        self._limit = limit
+        self._is_enabled = is_enabled
+        self._before_send = before_send
+        self._stopped = stopped
+
+    def get_meter(self, *args, **kwargs):
+        return _BoundedMeter(
+            self._meter_provider.get_meter(*args, **kwargs),
+            self._limit,
+            self._instruments,
+            self._is_enabled,
+            self._before_send,
+            self._stopped,
+        )
+
+    def __getattr__(self, name):
+        return getattr(self._meter_provider, name)
+
+
+@contextmanager
+def _stable_http_semconv() -> Iterator[None]:
+    """Selects the stable HTTP names (`http.server.request.duration`, seconds),
+    the same names posthog-node sends, while the instrumentors load.
+
+    OpenTelemetry reads the opt-in once per process. If another instrumentor
+    read it first, without an opt-in, the HTTP mode is set here, so the names
+    do not depend on import order. The process environment is restored
+    afterwards, so subprocesses and other code do not see the change.
+    An opt-in that the app set is kept."""
+    previous = os.environ.get(_SEMCONV_OPT_IN)
+    if previous is None:
+        os.environ[_SEMCONV_OPT_IN] = "http"
+    try:
+        try:
+            semconv = _import_module("opentelemetry.instrumentation._semconv")
+            stability = semconv._OpenTelemetrySemanticConventionStability
+            stability._initialize()
+            if previous is None:
+                stability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                    semconv._OpenTelemetryStabilitySignalType.HTTP
+                ] = semconv._StabilityMode.HTTP
+        except Exception:  # older instrumentation packages have no opt-in
+            pass
+        yield
+    finally:
+        if previous is None:
+            os.environ.pop(_SEMCONV_OPT_IN, None)
+
+
+@contextmanager
+def _patched_environ(values: Dict[str, Optional[str]]) -> Iterator[None]:
+    """Sets the environment variables (``None`` removes one) while OpenTelemetry
+    reads them, then restores the process environment."""
+    previous = {key: os.environ.get(key) for key in values}
+    try:
+        for key, value in values.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+        yield
+    finally:
+        for key, value in previous.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+
+
+def _posthog_url_pattern(host: str) -> str:
+    """An ``excluded_urls`` pattern for the PostHog host, in every form the HTTP
+    instrumentors see it: in any case, and with or without the default port."""
+    parts = urlsplit(host)
+    scheme = parts.scheme.lower()
+    hostname = parts.hostname
+    if not scheme or not hostname:
+        pattern = "^" + re.escape(host) + "(?:[/?#]|$)"
+    else:
+        if ":" in hostname:
+            hostname = f"[{hostname}]"
+        default_port = _DEFAULT_PORTS.get(scheme)
+        if parts.port is not None and parts.port != default_port:
+            port = f":{parts.port}"
+        else:
+            port = f"(?::{default_port})?" if default_port else ""
+        pattern = (
+            "^(?i:"
+            + re.escape(f"{scheme}://{hostname}")
+            + ")"
+            + port
+            + re.escape(parts.path.rstrip("/"))
+            + "(?:[/?#]|$)"
+        )
+    # The instrumentors split the excluded URLs at commas.
+    return pattern.replace(",", r"\x2c")
+
+
+def _excluded_urls(instrumentor_name: str, posthog_pattern: str) -> Tuple[str, str]:
+    """The excluded URLs for an HTTP client instrumentor: the PostHog host, and
+    the URLs that the app excludes in ``OTEL_PYTHON_*_EXCLUDED_URLS``. Returns
+    the instrumentor's environment variable too, which httpx and aiohttp read
+    in place of the ``excluded_urls`` argument."""
+    variable = (
+        f"OTEL_PYTHON_{instrumentor_name.upper().replace('-', '_')}_EXCLUDED_URLS"
+    )
+    excluded = os.environ.get(variable, os.environ.get("OTEL_PYTHON_EXCLUDED_URLS", ""))
+    return variable, ",".join(url for url in (posthog_pattern, excluded) if url)
+
+
+def _track_flask_apps(instrumentor_class: Any, providers: Dict[str, Any]) -> None:
+    flask: Any = _import_module("flask")
+    instrumented_flask = flask.Flask
+
+    class _TrackedFlask(instrumented_flask):  # type: ignore[misc,valid-type]
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # FlaskInstrumentor.uninstrument_app() needs `_teardown_request`, which
+            # only instrument_app() sets. The instrumented class registers that
+            # hook last.
+            teardown_funcs = self.teardown_request_funcs.get(None)
+            if not hasattr(self, "_teardown_request") and teardown_funcs:
+                self._teardown_request = teardown_funcs[-1]
+            self._posthog_wsgi_app = self.wsgi_app
+            _flask_apps.add(self)
+
+    flask.Flask = _TrackedFlask
+    for app in list(_flask_apps):
+        if not getattr(app, "_is_instrumented_by_opentelemetry", False):
+            if app._got_first_request:
+                log.warning(
+                    "Metrics autocapture skipped Flask app %r: it has already handled a request",
+                    app,
+                )
+                continue
+            instrumentor_class.instrument_app(app, **providers)
+            app._posthog_wsgi_app = app.wsgi_app
+
+
+def _uninstrument_flask_apps() -> None:
+    flask_instrumentation = sys.modules.get("opentelemetry.instrumentation.flask")
+    if flask_instrumentation is None:
+        return
+    for app in list(_flask_apps):
+        if not getattr(app, "_is_instrumented_by_opentelemetry", False):
+            continue
+        # uninstrument_app() restores the WSGI app saved when the app was
+        # instrumented, which would remove middleware that the app added later,
+        # such as authentication. Such an app keeps the instrumentation, which
+        # records nothing after shutdown, and is not measured again.
+        if getattr(app, "wsgi_app", None) is not getattr(
+            app, "_posthog_wsgi_app", None
+        ):
+            log.debug(
+                "Metrics autocapture left the instrumentation of %r in place", app
+            )
+            continue
+        flask_instrumentation.FlaskInstrumentor.uninstrument_app(app)
+
+
+def _django_settings_configured() -> bool:
+    conf = sys.modules.get("django.conf")
+    return bool(getattr(getattr(conf, "settings", None), "configured", False))
+
+
+def _no_inject(*args: Any, **kwargs: Any) -> None:
+    return None
+
+
+def _disable_propagation(instrumentor_class: Any) -> None:
+    """Replaces ``inject`` in the instrumentor's modules, which would send the
+    current trace context and baggage to other services. The instrumentors call
+    it through their module global, and autocapture owns these instrumentors
+    while it runs."""
+    inject = _import_module("opentelemetry.propagate").inject
+    package = instrumentor_class.__module__
+    if package.startswith("opentelemetry.instrumentation."):
+        # Such as `opentelemetry.instrumentation.tornado`, with its client module.
+        package = ".".join(package.split(".")[:3])
+    for name, module in list(sys.modules.items()):
+        if name != package and not name.startswith(package + "."):
+            continue
+        if getattr(module, "inject", None) is inject:
+            _replaced_injects[name] = inject
+            setattr(module, "inject", _no_inject)
+
+
+def _gate_aiohttp_trace_configs(
+    meter_provider: Any, stopped: threading.Event, posthog_url_pattern: str
+) -> None:
+    global _replaced_aiohttp_trace_config
+    module = _import_module("opentelemetry.instrumentation.aiohttp_client")
+    original = module.create_trace_config
+    posthog_urls = re.compile(posthog_url_pattern)
+
+    def create_trace_config(*args, **kwargs):
+        config = original(*args, **kwargs)
+        if kwargs.get("meter_provider") is meter_provider:
+            on_start = config.on_request_start[0]
+
+            async def on_request_start(session, trace_config_ctx, params):
+                if stopped.is_set() or posthog_urls.search(str(params.url)):
+                    trace_config_ctx.span = None
+                    return
+                await on_start(session, trace_config_ctx, params)
+
+            # Existing sessions retain these callbacks after uninstrumentation.
+            # Keep them inert before the module's real inject function is restored.
+            config.on_request_start[0] = on_request_start
+        return config
+
+    setattr(module, "create_trace_config", create_trace_config)
+    _replaced_aiohttp_trace_config = original, create_trace_config
+
+
+def _restore_propagation() -> None:
+    while _replaced_injects:
+        name, inject = _replaced_injects.popitem()
+        module = sys.modules.get(name)
+        if module is not None and getattr(module, "inject", None) is _no_inject:
+            setattr(module, "inject", inject)
+
+
+def _first_string(attributes: Any, keys: tuple) -> Optional[str]:
+    for key in keys:
+        value = attributes.get(key)
+        if isinstance(value, str) and value:
+            return value
+    return None
+
+
+class DbSpanMetricsProcessor(_SpanProcessorBase):
+    """Turns driver-level database client spans into a
+    ``db.client.operation.duration`` histogram.
+
+    Only bounded attributes are kept: never the statement, which holds values,
+    and never anything per-user.
+    """
+
+    def __init__(self, meter):
+        try:
+            self._histogram = meter.create_histogram(
+                _DB_OPERATION_DURATION,
+                unit="s",
+                description="Duration of database client operations.",
+                explicit_bucket_boundaries_advisory=_DB_DURATION_BUCKETS,
+            )
+        except TypeError:
+            # opentelemetry-api before 1.23 has no bucket advice.
+            self._histogram = meter.create_histogram(
+                _DB_OPERATION_DURATION,
+                unit="s",
+                description="Duration of database client operations.",
+            )
+
+    def on_start(self, span, parent_context=None):
+        pass
+
+    def on_end(self, span):
+        try:
+            self._record(span)
+        except Exception:  # never raise into the instrumented call
+            log.debug(
+                "Metrics autocapture failed to record a database span", exc_info=True
+            )
+
+    def _record(self, span):
+        from opentelemetry.trace import SpanKind, StatusCode
+
+        scope = getattr(span, "instrumentation_scope", None)
+        if (
+            span.kind != SpanKind.CLIENT
+            or getattr(scope, "name", None) not in _DERIVED_DB_METRIC_SCOPES
+        ):
+            return
+        attributes = span.attributes or {}
+        system = _first_string(attributes, ("db.system.name", "db.system"))
+        if not system or span.start_time is None or span.end_time is None:
+            return
+        metric_attributes: Dict[str, Any] = {"db.system.name": system}
+        operation = _first_string(attributes, ("db.operation.name", "db.operation"))
+        if operation is None:
+            statement = _first_string(attributes, ("db.query.text", "db.statement"))
+            match = _STATEMENT_KEYWORD.match(statement or "")
+            operation = match.group(1).upper() if match else None
+        else:
+            # Only the leading keyword is bounded, as for a statement.
+            words = operation.split()
+            operation = words[0] if words else None
+        collection = _first_string(
+            attributes,
+            (
+                "db.collection.name",
+                "db.mongodb.collection",
+                "db.sql.table",
+                "db.cassandra.table",
+            ),
+        )
+        namespace = _first_string(attributes, ("db.namespace", "db.name"))
+        address = _first_string(attributes, ("server.address", "net.peer.name"))
+        port = attributes.get("server.port", attributes.get("net.peer.port"))
+        if operation:
+            metric_attributes["db.operation.name"] = operation
+        if collection:
+            metric_attributes["db.collection.name"] = collection
+        if namespace:
+            metric_attributes["db.namespace"] = namespace
+        if address:
+            metric_attributes["server.address"] = address
+        if isinstance(port, int) and not isinstance(port, bool):
+            metric_attributes["server.port"] = port
+        if span.status.status_code == StatusCode.ERROR:
+            metric_attributes["error.type"] = (
+                _first_string(attributes, ("error.type",)) or "_OTHER"
+            )
+        self._histogram.record(
+            (span.end_time - span.start_time) / 1e9, metric_attributes
+        )
+
+    def _on_ending(self, span):
+        pass
+
+    def shutdown(self):
+        pass
+
+    def force_flush(self, timeout_millis=30000):
+        return True
+
+
+class MetricsAutocapture:
+    """The running autocapture. ``shutdown()`` exports the last window and
+    removes the instrumentation."""
+
+    def __init__(
+        self,
+        meter_provider,
+        tracer_provider,
+        instrumentors,
+        reader,
+        stopped: Optional[threading.Event] = None,
+    ):
+        self._meter_provider = meter_provider
+        self._tracer_provider = tracer_provider
+        self._instrumentors = instrumentors
+        self._reader = reader
+        self._stopped = stopped if stopped is not None else threading.Event()
+        self._reset_flush_state()
+
+    def force_flush(self, timeout_millis: int = 10_000) -> None:
+        self._meter_provider.force_flush(timeout_millis)
+
+    def _reset_flush_state(self) -> None:
+        self._flush_done = threading.Condition()
+        self._flush_thread: Optional[threading.Thread] = None
+        # Flush requests are numbered. An export covers the requests made
+        # before it starts.
+        self._flush_requested = 0
+        self._flush_exported = 0
+
+    def start_flush(self) -> Optional[Callable[[Optional[float]], bool]]:
+        """Starts an export of the current window. Returns a function that waits
+        for it, at most the given seconds, and returns whether it finished; or
+        ``None`` when there is nothing to wait for.
+
+        One thread exports at a time. A call made while it exports gets one more
+        export, so the measurements recorded before the call are also sent, and
+        callers with short timeouts do not start a thread each. Each call waits
+        only for the first export that starts after it."""
+        with self._flush_done:
+            self._flush_requested += 1
+            request = self._flush_requested
+            flusher = self._flush_thread
+            if flusher is threading.current_thread():
+                # From the export itself, waiting would never end.
+                return None
+            if flusher is None:
+                flusher = threading.Thread(
+                    target=self._flush_until_done,
+                    name="posthog-metrics-autocapture-flush",
+                    daemon=True,
+                )
+                try:
+                    flusher.start()
+                except RuntimeError:  # no new threads at interpreter shutdown
+                    self._flush_requested -= 1
+                    return None
+                self._flush_thread = flusher
+
+        def wait(timeout: Optional[float] = None) -> bool:
+            with self._flush_done:
+                return self._flush_done.wait_for(
+                    lambda: self._flush_exported >= request, timeout
+                )
+
+        return wait
+
+    def _flush_until_done(self) -> None:
+        while True:
+            with self._flush_done:
+                covered = self._flush_requested
+            self._flush_quietly()
+            with self._flush_done:
+                self._flush_exported = covered
+                self._flush_done.notify_all()
+                if self._flush_requested == covered:
+                    self._flush_thread = None
+                    return
+
+    def _flush_quietly(self) -> None:
+        try:
+            self._meter_provider.force_flush()
+        except Exception:
+            log.debug("Metrics autocapture failed to flush", exc_info=True)
+
+    def _reinit_after_fork(self) -> None:
+        # The instrumentation and the providers stay active in the child, and the
+        # OpenTelemetry metric reader restarts its export thread there. The reader
+        # does not replace its export lock, which the parent's export thread can
+        # hold at fork time.
+        if getattr(self._reader, "_export_lock", None) is not None:
+            self._reader._export_lock = threading.Lock()
+        # The parent's flush thread does not exist in the child.
+        self._reset_flush_state()
+        try:
+            _replace_collection_locks(self._meter_provider)
+        except Exception:
+            log.debug(
+                "Metrics autocapture failed to reset locks after fork", exc_info=True
+            )
+        # The runtime instrumentor keeps the process it was created in, so it
+        # would report the parent process.
+        for instrumentor in self._instrumentors:
+            try:
+                psutil = _import_module("psutil")
+                if isinstance(getattr(instrumentor, "_proc", None), psutil.Process):
+                    instrumentor._proc = psutil.Process(os.getpid())
+            except Exception:
+                log.debug(
+                    "Metrics autocapture failed to update %s after fork",
+                    instrumentor,
+                    exc_info=True,
+                )
+
+    def shutdown(self) -> None:
+        global _active
+        with _lock:
+            if _active is not self:
+                return
+            self._stopped.set()
+            # Uninstrument before another client can start. It would skip the
+            # libraries that are still instrumented, and then lose them here.
+            _uninstrument(self._instrumentors)
+            _active = None
+        # The last export can take a while, so it runs outside the lock.
+        _shut_down(self._tracer_provider, self._meter_provider)
+
+
+def _uninstrument(instrumentors: List[Any]) -> None:
+    global _replaced_aiohttp_trace_config
+    for instrumentor in instrumentors:
+        try:
+            instrumentor.uninstrument()
+        except Exception:
+            log.debug(
+                "Metrics autocapture failed to uninstrument %s",
+                instrumentor,
+                exc_info=True,
+            )
+    try:
+        _uninstrument_flask_apps()
+    except Exception:
+        log.debug(
+            "Metrics autocapture failed to uninstrument Flask apps", exc_info=True
+        )
+    if _replaced_aiohttp_trace_config is not None:
+        original, replacement = _replaced_aiohttp_trace_config
+        module = sys.modules.get("opentelemetry.instrumentation.aiohttp_client")
+        if module is not None and module.create_trace_config is replacement:
+            setattr(module, "create_trace_config", original)
+        _replaced_aiohttp_trace_config = None
+    _restore_propagation()
+
+
+def _fresh_lock(owner: Any, name: str = "_lock") -> None:
+    lock = getattr(owner, name, None)
+    if lock is None:
+        return
+    rlock_type = type(threading.RLock())
+    setattr(
+        owner,
+        name,
+        threading.RLock() if isinstance(lock, rlock_type) else threading.Lock(),
+    )
+
+
+def _replace_collection_locks(meter_provider: Any) -> None:
+    """Replaces the locks of the metrics SDK that a parent thread can hold at
+    fork time, while it collects or records. The SDK replaces only the locks of
+    the meter provider itself. In the child, no thread holds these locks."""
+    for meter in list(getattr(meter_provider, "_meters", {}).values()):
+        _fresh_lock(meter, "_instrument_registration_lock")
+    consumer = getattr(meter_provider, "_measurement_consumer", None)
+    if consumer is None:
+        return
+    _fresh_lock(consumer)
+    for storage in list(getattr(consumer, "_reader_storages", {}).values()):
+        _fresh_lock(storage)
+        matches_by_instrument = getattr(
+            storage, "_instrument_view_instrument_matches", {}
+        )
+        for matches in list(matches_by_instrument.values()):
+            for match in matches:
+                _fresh_lock(match)
+                for aggregation in list(
+                    getattr(match, "_attributes_aggregation", {}).values()
+                ):
+                    _fresh_lock(aggregation)
+                    _fresh_lock(getattr(aggregation, "_reservoir", None))
+
+
+def _shut_down(*components: Any) -> None:
+    for component in components:
+        if component is None:
+            continue
+        try:
+            component.shutdown()
+        except Exception:
+            log.debug(
+                "Metrics autocapture failed to shut down %s",
+                component,
+                exc_info=True,
+            )
+
+
+def _reinit_after_fork() -> None:
+    global _lock
+    # A parent thread can hold the lock at fork time. Replace it, never acquire it.
+    _lock = threading.Lock()
+    active = _active
+    if active is not None:
+        active._reinit_after_fork()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_reinit_after_fork)
+
+
+def _metrics_export_session(api_key: str) -> Any:
+    session_base: Any = _import_module("requests").Session
+
+    class _MetricsSession(session_base):
+        def request(self, method, url, **kwargs):
+            # Exporters merge application OTLP headers and TLS settings even with
+            # explicit constructor arguments. Isolate them at the private transport.
+            self.headers.clear()
+            self.cert = None
+            kwargs.update(
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/x-protobuf",
+                },
+                verify=True,
+                cert=None,
+            )
+            return super().request(method, url, **kwargs)
+
+    return _MetricsSession()
+
+
+def _is_default_provider(provider: Any) -> bool:
+    name = type(provider).__name__
+    return name.startswith(("_Proxy", "Proxy", "NoOp", "_NoOp", "Default"))
+
+
+def _instrumentor_names(areas: Dict[str, bool]) -> List[str]:
+    names: List[str] = []
+    if areas.get("http"):
+        names.extend(_HTTP_CLIENT_INSTRUMENTORS + _HTTP_SERVER_INSTRUMENTORS)
+    if areas.get("db"):
+        names.extend(_DB_INSTRUMENTORS)
+    if areas.get("runtime"):
+        names.append("system_metrics")
+    return names
+
+
+def start_metrics_autocapture(
+    *,
+    host: str,
+    api_key: str,
+    areas: Dict[str, bool],
+    service_name: Optional[str],
+    resource_attributes: Dict[str, Any],
+    is_enabled: Callable[[], bool],
+    export_interval_seconds: Optional[float] = None,
+    before_send: Optional[Callable] = None,
+    _metric_reader: Any = None,
+) -> Optional[MetricsAutocapture]:
+    """Starts metrics autocapture. Returns ``None``, after one warning, when the
+    OpenTelemetry packages are missing, when OpenTelemetry is already set up in
+    the process, or when autocapture is already running. Never raises.
+
+    ``before_send`` is the ``metrics.before_send`` hook. It gets each
+    measurement as a ``client.metrics`` sample and can change its value and
+    attributes, or drop it."""
+    global _active, _warned_about_missing_packages
+    host = host.rstrip("/")
+    with _lock:
+        if _active is not None:
+            log.warning(
+                "Metrics autocapture is already running in this process, so this client does not start it again."
+            )
+            return None
+        try:
+            metrics_api = _import_module("opentelemetry.metrics")
+            trace_api = _import_module("opentelemetry.trace")
+            sdk_metrics = _import_module("opentelemetry.sdk.metrics")
+            sdk_metrics_export = _import_module("opentelemetry.sdk.metrics.export")
+            sdk_trace = _import_module("opentelemetry.sdk.trace")
+            sampling = _import_module("opentelemetry.sdk.trace.sampling")
+            sdk_resources = _import_module("opentelemetry.sdk.resources")
+            otlp = _import_module(
+                "opentelemetry.exporter.otlp.proto.http.metric_exporter"
+            )
+            _import_module("opentelemetry.instrumentation")
+        except ImportError as e:
+            if not _warned_about_missing_packages:
+                _warned_about_missing_packages = True
+                log.warning(
+                    "Metrics autocapture needs the OpenTelemetry packages. Install them with: %s (%s)",
+                    _INSTALL_HINT,
+                    e,
+                )
+            return None
+
+        reader: Any = None
+        meter_provider: Any = None
+        tracer_provider: Any = None
+        instrumentors: List[Any] = []
+        stopped = threading.Event()
+        try:
+            if not _is_default_provider(
+                metrics_api.get_meter_provider()
+            ) or not _is_default_provider(trace_api.get_tracer_provider()):
+                log.warning(
+                    "OpenTelemetry is already set up in this process, so metrics autocapture does not start. "
+                    "Point your OTLP metrics exporter at PostHog instead: https://posthog.com/docs/metrics"
+                )
+                return None
+
+            # The same resource as `client.metrics`: the OTEL_SERVICE_NAME and
+            # OTEL_RESOURCE_ATTRIBUTES of the app are not read.
+            resource = sdk_resources.Resource(
+                {
+                    **resource_attributes,
+                    "service.name": service_name or "unknown_service",
+                    "telemetry.sdk.language": "python",
+                    "telemetry.sdk.name": "opentelemetry",
+                    "telemetry.sdk.version": _import_module(
+                        "opentelemetry.sdk.version"
+                    ).__version__,
+                    "telemetry.distro.name": "posthog-python",
+                    "telemetry.distro.version": VERSION,
+                }
+            )
+
+            reader = _metric_reader
+            if reader is None:
+                exporter_base: Any = otlp.OTLPMetricExporter
+                delta = sdk_metrics_export.AggregationTemporality.DELTA
+                cumulative = sdk_metrics_export.AggregationTemporality.CUMULATIVE
+
+                class _GatedExporter(exporter_base):
+                    # The exporter still sends while the client is disabled unless it is gated here.
+                    def export(self, metrics_data, timeout_millis=10_000, **kwargs):
+                        if not is_enabled():
+                            return sdk_metrics_export.MetricExportResult.SUCCESS
+                        return super().export(
+                            metrics_data, timeout_millis=timeout_millis, **kwargs
+                        )
+
+                exporter = _GatedExporter(
+                    endpoint=f"{host}/i/v1/metrics",
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    timeout=_EXPORT_TIMEOUT_SECONDS,
+                    compression=_import_module(
+                        "opentelemetry.exporter.otlp.proto.http"
+                    ).Compression.NoCompression,
+                    session=_metrics_export_session(api_key),
+                    # Delta, like the `posthog.metrics` wire shape; values that go
+                    # up and down stay cumulative.
+                    preferred_temporality={
+                        sdk_metrics.Counter: delta,
+                        sdk_metrics.Histogram: delta,
+                        sdk_metrics.ObservableCounter: delta,
+                        sdk_metrics.UpDownCounter: cumulative,
+                        sdk_metrics.ObservableUpDownCounter: cumulative,
+                        sdk_metrics.ObservableGauge: cumulative,
+                    },
+                    preferred_aggregation={
+                        sdk_metrics.Histogram: _import_module(
+                            "opentelemetry.sdk.metrics.view"
+                        ).ExplicitBucketHistogramAggregation(),
+                    },
+                )
+                reader = sdk_metrics_export.PeriodicExportingMetricReader(
+                    exporter,
+                    export_interval_millis=(export_interval_seconds or 10.0) * 1000,
+                )
+            # The client exports the last window at exit, within its exit budget.
+            # The provider's own exit hook waits up to the export timeout, also
+            # when the PostHog host does not answer.
+            meter_provider = sdk_metrics.MeterProvider(
+                resource=resource, metric_readers=[reader], shutdown_on_exit=False
+            )
+
+            sampler_base: Any = sampling.Sampler
+
+            class _ClientSpansOnly(sampler_base):
+                # Records only client spans, the ones a database call makes. Database
+                # instrumentors set `db.system` after start, so the kind is all a
+                # sampler can check. Server spans stay no-ops.
+                def should_sample(
+                    self,
+                    parent_context,
+                    trace_id,
+                    name,
+                    kind=None,
+                    attributes=None,
+                    links=None,
+                    trace_state=None,
+                ):
+                    if kind != trace_api.SpanKind.CLIENT:
+                        return sampling.SamplingResult(sampling.Decision.DROP)
+                    # A recorded span starts with these attributes only. Some
+                    # instrumentors, such as asyncpg, pass `db.system` here.
+                    return sampling.SamplingResult(
+                        sampling.Decision.RECORD_ONLY, attributes
+                    )
+
+                def get_description(self):
+                    return "PostHogClientSpansOnly"
+
+            bounded_meter_provider = _BoundedMeterProvider(
+                meter_provider, _MAX_ATTRIBUTE_SETS, is_enabled, before_send, stopped
+            )
+            tracer_provider = sdk_trace.TracerProvider(
+                resource=resource, sampler=_ClientSpansOnly(), shutdown_on_exit=False
+            )
+            # A span of the private provider is still the current span, so an HTTP
+            # client would send its trace context to other services (as "not
+            # sampled", which makes them drop their traces). HTTP metrics do not
+            # need spans.
+            no_op_tracer_provider = trace_api.NoOpTracerProvider()
+            if areas.get("db"):
+                tracer_provider.add_span_processor(
+                    DbSpanMetricsProcessor(
+                        bounded_meter_provider.get_meter(
+                            "posthog.metrics_autocapture", VERSION
+                        )
+                    )
+                )
+
+            posthog_url_pattern = _posthog_url_pattern(host)
+            wanted = set(_instrumentor_names(areas))
+            with _stable_http_semconv():
+                for entry_point in entry_points(group="opentelemetry_instrumentor"):
+                    if entry_point.name not in wanted:
+                        continue
+                    if (
+                        entry_point.name == "django"
+                        and not _django_settings_configured()
+                    ):
+                        # Without settings, the Django instrumentor configures empty
+                        # ones, and the app's own settings.configure() then fails.
+                        # In AppConfig.ready() the settings are configured.
+                        log.debug(
+                            "Metrics autocapture skipped django: its settings are not configured yet"
+                        )
+                        continue
+                    try:
+                        kwargs: Dict[str, Any] = {
+                            "tracer_provider": tracer_provider
+                            if entry_point.name in _DB_INSTRUMENTORS
+                            else no_op_tracer_provider,
+                            "meter_provider": bounded_meter_provider,
+                        }
+                        environ: Dict[str, Optional[str]] = {}
+                        if entry_point.name in _HTTP_CLIENT_INSTRUMENTORS:
+                            # PostHog's own uploads, including this exporter's, are not app traffic.
+                            variable, excluded = _excluded_urls(
+                                entry_point.name, posthog_url_pattern
+                            )
+                            kwargs["excluded_urls"] = excluded
+                            environ[variable] = excluded
+                        with _patched_environ(environ):
+                            instrumentor_class = entry_point.load()
+                            # Instrumentors are singletons, and creating one runs
+                            # `__init__` again on the existing instance. That would
+                            # reset the config of an instance that the app uses.
+                            existing = getattr(instrumentor_class, "_instance", None)
+                            if (
+                                existing is not None
+                                and existing.is_instrumented_by_opentelemetry
+                            ):
+                                continue
+                            instrumentor = (
+                                instrumentor_class(config=_RUNTIME_CONFIG)
+                                if entry_point.name == "system_metrics"
+                                else instrumentor_class()
+                            )
+                            if instrumentor.is_instrumented_by_opentelemetry:
+                                # The app instrumented this library itself.
+                                continue
+                            instrumentor.instrument(**kwargs)
+                        if instrumentor.is_instrumented_by_opentelemetry:
+                            instrumentors.append(instrumentor)
+                            _disable_propagation(instrumentor_class)
+                            if entry_point.name == "aiohttp-client":
+                                _gate_aiohttp_trace_configs(
+                                    bounded_meter_provider, stopped, posthog_url_pattern
+                                )
+                            if entry_point.name == "flask":
+                                _track_flask_apps(
+                                    instrumentor_class,
+                                    {
+                                        "tracer_provider": no_op_tracer_provider,
+                                        "meter_provider": bounded_meter_provider,
+                                    },
+                                )
+                    except Exception:
+                        log.debug(
+                            "Metrics autocapture skipped %s",
+                            entry_point.name,
+                            exc_info=True,
+                        )
+
+            _active = MetricsAutocapture(
+                meter_provider, tracer_provider, instrumentors, reader, stopped
+            )
+            return _active
+        except Exception:
+            log.exception("Metrics autocapture failed to start")
+            # Each start attempt would otherwise leave an export thread behind.
+            stopped.set()
+            _uninstrument(instrumentors)
+            _shut_down(tracer_provider, meter_provider or reader)
+            return None
diff --git a/posthog/client.py b/posthog/client.py
index 5d0a92ca4..3b918b0ba 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -19,7 +19,12 @@
 from posthog._async_utils import _BackgroundEventLoopRunner
 from posthog._disabled_lane_queue import _DisabledLaneQueue
 from posthog.args import ID_TYPES, ExceptionArg, OptionalCaptureArgs, OptionalSetArgs
-from posthog.metrics_capture import PostHogMetrics
+from posthog.metrics_capture import (
+    _DEFAULT_FLUSH_INTERVAL_SECONDS,
+    PostHogMetrics,
+    _validated_before_send,
+    _validated_flush_interval,
+)
 from posthog.tracing._config import resolve_traces_config
 from posthog.tracing._drops import DropLog
 from posthog.tracing._export import SpanExporter
@@ -886,10 +891,16 @@ def __init__(
         self._lifecycle_callback_context: ContextVar[bool] = ContextVar(
             "posthog_lifecycle_callback", default=False
         )
+        # Set while a metrics `before_send` hook runs: a flush it calls does not
+        # start another autocapture export, which would run the hook again.
+        self._skip_metrics_autocapture_flush: ContextVar[bool] = ContextVar(
+            "posthog_skip_metrics_autocapture_flush", default=False
+        )
         self._deferred_flush_lock = threading.Lock()
         self._deferred_flush_pending = False
         self._deferred_flush_followup = False
         self._deferred_flush_followup_timeout: Optional[float] = None
+        self._deferred_flush_followup_metrics = False
         # Used for session replay URL generation - we don't want the server host here.
         self.raw_host = normalize_host(host)
         self.host = determine_server_host(host)
@@ -1117,6 +1128,10 @@ def __init__(
         )
         self._lanes = [self._analytics_lane, self._ai_lane]
 
+        self._metrics_autocapture: Optional[Any] = None
+        self._metrics_autocapture_tried = False
+        self._start_metrics_autocapture_once(metrics)
+
         if hasattr(os, "register_at_fork"):
             weak_self = weakref.ref(self)
             os.register_at_fork(
@@ -1125,6 +1140,81 @@ def __init__(
 
         self._warn_if_duplicate_async_client()
 
+    def _start_metrics_autocapture_once(self, metrics_config: Any) -> None:
+        """Starts metrics autocapture when the ``metrics`` option asks for it. A
+        client tries once, so a module-level ``setup()`` on each call does not
+        start it again or repeat a warning."""
+        autocapture = (
+            metrics_config.get("autocapture")
+            if isinstance(metrics_config, dict)
+            else None
+        )
+        if not autocapture or self.disabled or self._metrics_autocapture_tried:
+            return
+        self._metrics_autocapture_tried = True
+        self._metrics_autocapture = self._start_metrics_autocapture(
+            metrics_config, autocapture if isinstance(autocapture, dict) else {}
+        )
+        # Sync mode has no exit hook for events; the window needs its own.
+        if self._metrics_autocapture is not None and self.sync_mode and self.send:
+            atexit.register(self._atexit_metrics_autocapture)
+
+    def _start_metrics_autocapture(self, metrics_config: dict, areas: dict):
+        # Imported here, so a client without autocapture never loads OpenTelemetry.
+        from ._metrics_autocapture import start_metrics_autocapture
+
+        resource_attributes = metrics_config.get("resource_attributes")
+        resource_attributes = (
+            dict(resource_attributes) if isinstance(resource_attributes, dict) else {}
+        )
+        for key, attribute in (
+            ("service_version", "service.version"),
+            ("environment", "deployment.environment"),
+        ):
+            if metrics_config.get(key) and attribute not in resource_attributes:
+                resource_attributes[attribute] = metrics_config[key]
+        weak_self = weakref.ref(self)
+        before_send = _validated_before_send(metrics_config.get("before_send"))
+        if before_send is not None:
+            hook = before_send
+
+            def run_as_callback(sample):
+                # The hook runs while OpenTelemetry collects or records. As an
+                # SDK callback, a flush() or shutdown() it calls is deferred, so
+                # it does not wait for that same collection.
+                client = weak_self()
+                if client is None:
+                    return hook(sample)
+                callback_token = client._lifecycle_callback_context.set(True)
+                skip_token = client._skip_metrics_autocapture_flush.set(True)
+                try:
+                    return hook(sample)
+                finally:
+                    client._skip_metrics_autocapture_flush.reset(skip_token)
+                    client._lifecycle_callback_context.reset(callback_token)
+
+            before_send = run_as_callback
+
+        return start_metrics_autocapture(
+            host=self.host,
+            api_key=self.api_key,
+            areas={
+                "http": areas.get("http", True),
+                "db": areas.get("db", True),
+                "runtime": areas.get("runtime", True),
+            },
+            service_name=resource_attributes.get("service.name")
+            or metrics_config.get("service_name"),
+            resource_attributes=resource_attributes,
+            is_enabled=lambda: (client := weak_self()) is not None
+            and not client.disabled
+            and client.send,
+            export_interval_seconds=_validated_flush_interval(
+                metrics_config.get("flush_interval", _DEFAULT_FLUSH_INTERVAL_SECONDS)
+            ),
+            before_send=before_send,
+        )
+
     def _set_library_identity(self, library_id: str, library_version: str) -> None:
         """Override the SDK identity stamped on events and outbound requests."""
         self._library_id = library_id
@@ -2332,10 +2422,14 @@ def _reinit_after_fork(self):
         self._lifecycle_callback_context = ContextVar(
             "posthog_lifecycle_callback", default=False
         )
+        self._skip_metrics_autocapture_flush = ContextVar(
+            "posthog_skip_metrics_autocapture_flush", default=False
+        )
         self._deferred_flush_lock = threading.Lock()
         self._deferred_flush_pending = False
         self._deferred_flush_followup = False
         self._deferred_flush_followup_timeout = None
+        self._deferred_flush_followup_metrics = False
 
         # Async runner threads do not survive fork(); recreate lazily on next async cache call.
         self._flag_definition_cache_provider_async_runner = None
@@ -2720,7 +2814,7 @@ def get_active_span(self) -> Optional[Span]:
 
     def flush(self, timeout_seconds: Optional[float] = 10) -> None:
         """
-        Attempt immediate delivery of queued events and ended spans, keeping the client reusable.
+        Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.
 
         For a client shared across requests or serverless invocations (including
         the module-level client), call ``flush()`` before a short-lived invocation
@@ -2757,12 +2851,22 @@ def flush(self, timeout_seconds: Optional[float] = 10) -> None:
             posthog.flush(timeout_seconds=10)
             ```
         """
-        if self._defer_flush_from_callback(timeout_seconds):
+        include_metrics_autocapture = not self._skip_metrics_autocapture_flush.get()
+        if self._defer_flush_from_callback(
+            timeout_seconds, include_metrics_autocapture
+        ):
             return
         try:
             # Spans drain with events: serverless handlers call flush(), not
             # shutdown(), and leaving spans on their own timer would lose them.
             span_flush = self._start_span_flush(timeout_seconds)
+            # Autocaptured metrics would otherwise wait for their export timer.
+            metrics_flush = (
+                self._start_metrics_autocapture_flush()
+                if include_metrics_autocapture
+                else None
+            )
+            deadline: Optional[float] = None
             if timeout_seconds is None:
                 for lane in self._lanes:
                     lane.flush(None)
@@ -2770,6 +2874,10 @@ def flush(self, timeout_seconds: Optional[float] = 10) -> None:
                 deadline = time.monotonic() + timeout_seconds
                 for lane in self._lanes:
                     lane.flush(max(0.0, deadline - time.monotonic()))
+            if metrics_flush is not None:
+                metrics_flush(
+                    None if deadline is None else max(0.0, deadline - time.monotonic())
+                )
             if span_flush is not None:
                 # The last span request is bounded only by the request
                 # timeout, so the wait is not.
@@ -2778,6 +2886,12 @@ def flush(self, timeout_seconds: Optional[float] = 10) -> None:
             self.log.exception("error flushing queue: %s", e)
             return
 
+    def _start_metrics_autocapture_flush(
+        self,
+    ) -> Optional[Callable[[Optional[float]], None]]:
+        autocapture = self._metrics_autocapture
+        return autocapture.start_flush() if autocapture is not None else None
+
     def _start_span_flush(
         self, timeout_seconds: Optional[float]
     ) -> Optional[Callable[[Optional[float]], None]]:
@@ -2857,7 +2971,9 @@ def run() -> None:
         self._start_lifecycle_thread(run, "lifecycle")
         return True
 
-    def _defer_flush_from_callback(self, timeout_seconds: Optional[float]) -> bool:
+    def _defer_flush_from_callback(
+        self, timeout_seconds: Optional[float], include_metrics_autocapture: bool = True
+    ) -> bool:
         if not self._is_lifecycle_callback_thread():
             return False
         with self._deferred_flush_lock:
@@ -2865,7 +2981,12 @@ def _defer_flush_from_callback(self, timeout_seconds: Optional[float]) -> bool:
                 if not self._deferred_flush_followup:
                     self._deferred_flush_followup = True
                     self._deferred_flush_followup_timeout = timeout_seconds
-                elif (
+                    self._deferred_flush_followup_metrics = include_metrics_autocapture
+                    return True
+                self._deferred_flush_followup_metrics = (
+                    self._deferred_flush_followup_metrics or include_metrics_autocapture
+                )
+                if (
                     self._deferred_flush_followup_timeout is not None
                     and timeout_seconds is not None
                 ):
@@ -2879,13 +3000,20 @@ def _defer_flush_from_callback(self, timeout_seconds: Optional[float]) -> bool:
 
         def run() -> None:
             next_timeout = timeout_seconds
+            next_metrics = include_metrics_autocapture
             while True:
-                self.flush(next_timeout)
+                skip_token = self._skip_metrics_autocapture_flush.set(not next_metrics)
+                try:
+                    self.flush(next_timeout)
+                finally:
+                    self._skip_metrics_autocapture_flush.reset(skip_token)
                 with self._deferred_flush_lock:
                     if self._deferred_flush_followup:
                         next_timeout = self._deferred_flush_followup_timeout
+                        next_metrics = self._deferred_flush_followup_metrics
                         self._deferred_flush_followup = False
                         self._deferred_flush_followup_timeout = None
+                        self._deferred_flush_followup_metrics = False
                         continue
                     self._deferred_flush_pending = False
                     return
@@ -2997,6 +3125,15 @@ def _shutdown_once(self, errors: list[Exception]) -> None:
             self._run_lifecycle_cleanup(
                 "Failed to reset metrics on shutdown", self._metrics.reset, errors
             )
+        if self._metrics_autocapture is not None:
+            # Exports the last window, then removes the instrumentation.
+            self._run_lifecycle_cleanup(
+                "Failed to shut down metrics autocapture",
+                self._metrics_autocapture.shutdown,
+                errors,
+            )
+            self._metrics_autocapture = None
+            atexit.unregister(self._atexit_metrics_autocapture)
         with self._traces_lock:
             traces = self._traces
         if traces is not None:
@@ -3098,8 +3235,11 @@ def _atexit(self) -> None:
                 span_flush = self._start_span_flush(
                     max(0.0, deadline - time.monotonic())
                 )
+                metrics_flush = self._start_metrics_autocapture_flush()
                 for lane in self._lanes:
                     lane.flush(max(0.0, deadline - time.monotonic()))
+                if metrics_flush is not None:
+                    metrics_flush(max(0.0, deadline - time.monotonic()))
                 self._join_span_flush(span_flush, deadline)
             finally:
                 # Consumers are daemon threads. Publish a non-draining stop to
@@ -3112,6 +3252,12 @@ def _atexit(self) -> None:
                 self._lifecycle_owner = None
                 self._lifecycle_condition.notify_all()
 
+    @no_throw()
+    def _atexit_metrics_autocapture(self) -> None:
+        waiter = self._start_metrics_autocapture_flush()
+        if waiter is not None:
+            waiter(max(0.0, _get_atexit_deadline() - time.monotonic()))
+
     @no_throw()
     def _atexit_spans(self) -> None:
         # The span timer is a daemon thread that dies at exit.
diff --git a/posthog/metrics_capture.py b/posthog/metrics_capture.py
index 781aa89b3..3d8bc15d4 100644
--- a/posthog/metrics_capture.py
+++ b/posthog/metrics_capture.py
@@ -272,6 +272,28 @@ def __init__(
         self.exemplar: Optional[dict] = None
 
 
+def _validated_flush_interval(flush_interval: Any) -> float:
+    # Shared with metrics autocapture, which reads the same option.
+    if (
+        not isinstance(flush_interval, (int, float))
+        or isinstance(flush_interval, bool)
+        or not flush_interval > 0
+    ):
+        log.warning(
+            "Ignoring metrics flush_interval %r: expected a positive number of seconds",
+            flush_interval,
+        )
+        return _DEFAULT_FLUSH_INTERVAL_SECONDS
+    return float(flush_interval)
+
+
+def _validated_before_send(before_send: Any) -> Optional[Callable]:
+    if before_send is not None and not callable(before_send):
+        log.warning("Ignoring metrics before_send: expected a callable")
+        return None
+    return before_send
+
+
 class PostHogMetrics:
     """The ``client.metrics`` API: ``count``, ``gauge``, ``histogram``, ``flush``.
 
@@ -318,18 +340,9 @@ def __init__(self, client, config: Optional[dict] = None):
             "deployment.environment"
         ) or config.get("environment")
         self._resource_attributes: dict = resource_attributes
-        flush_interval = config.get("flush_interval", _DEFAULT_FLUSH_INTERVAL_SECONDS)
-        if (
-            not isinstance(flush_interval, (int, float))
-            or isinstance(flush_interval, bool)
-            or not flush_interval > 0
-        ):
-            log.warning(
-                "Ignoring metrics flush_interval %r: expected a positive number of seconds",
-                flush_interval,
-            )
-            flush_interval = _DEFAULT_FLUSH_INTERVAL_SECONDS
-        self._flush_interval: float = float(flush_interval)
+        self._flush_interval: float = _validated_flush_interval(
+            config.get("flush_interval", _DEFAULT_FLUSH_INTERVAL_SECONDS)
+        )
         max_series = config.get("max_series_per_flush", _DEFAULT_MAX_SERIES_PER_FLUSH)
         if (
             not isinstance(max_series, int)
@@ -342,11 +355,9 @@ def __init__(self, client, config: Optional[dict] = None):
             )
             max_series = _DEFAULT_MAX_SERIES_PER_FLUSH
         self._max_series_per_flush: int = max_series
-        before_send = config.get("before_send")
-        if before_send is not None and not callable(before_send):
-            log.warning("Ignoring metrics before_send: expected a callable")
-            before_send = None
-        self._before_send: Optional[Callable] = before_send
+        self._before_send: Optional[Callable] = _validated_before_send(
+            config.get("before_send")
+        )
 
         self._lock = threading.Lock()
         self._pid = os.getpid()
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index f5fbbcbe3..4b0057309 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -1403,9 +1403,10 @@ def test_tool_calls(mock_client):
     )
 
 
-async def test_async_traces(mock_client):
+@pytest.mark.parametrize("delay", [0, 0.1])
+async def test_async_traces(mock_client, delay):
     async def sleep(x):  # -> Any:
-        await asyncio.sleep(0.1)
+        await asyncio.sleep(delay)
         return x
 
     prompt = ChatPromptTemplate.from_messages([("user", "Foo")])
@@ -1422,18 +1423,22 @@ async def sleep(x):  # -> Any:
     approximate_latency = math.floor(time.time() - start_time)
     assert mock_client.capture.call_count == 4
 
-    first_call, second_call, third_call, fourth_call = (
-        mock_client.capture.call_args_list
-    )
-    assert first_call[1]["event"] == "$ai_span"
-    assert second_call[1]["event"] == "$ai_generation"
-    assert third_call[1]["event"] == "$ai_trace"
-    assert third_call[1]["properties"]["$ai_span_name"] == "RunnableSequence"
-    assert fourth_call[1]["event"] == "$ai_trace"
-    assert fourth_call[1]["properties"]["$ai_span_name"] == "sleep"
+    calls = [call.kwargs for call in mock_client.capture.call_args_list]
+    assert sorted(call["event"] for call in calls) == [
+        "$ai_generation",
+        "$ai_span",
+        "$ai_trace",
+        "$ai_trace",
+    ]
+    traces = {
+        call["properties"]["$ai_span_name"]: call["properties"]
+        for call in calls
+        if call["event"] == "$ai_trace"
+    }
+    assert set(traces) == {"RunnableSequence", "sleep"}
     assert (
         min(approximate_latency - 1, 0)
-        <= math.floor(third_call[1]["properties"]["$ai_latency"])
+        <= math.floor(traces["RunnableSequence"]["$ai_latency"])
         <= approximate_latency
     )
 
diff --git a/posthog/test/test_metrics_autocapture.py b/posthog/test/test_metrics_autocapture.py
new file mode 100644
index 000000000..e69310b49
--- /dev/null
+++ b/posthog/test/test_metrics_autocapture.py
@@ -0,0 +1,1716 @@
+import os
+import socket
+import sqlite3
+import subprocess
+import sys
+import textwrap
+import threading
+import time
+from contextlib import ExitStack, contextmanager
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from unittest import mock
+
+import aiohttp
+import flask
+import httpx
+import opentelemetry.propagate
+import pytest
+import requests
+from opentelemetry import baggage, context, trace
+from opentelemetry.instrumentation._semconv import (
+    _OpenTelemetrySemanticConventionStability,
+)
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+from opentelemetry.instrumentation.system_metrics import SystemMetricsInstrumentor
+from opentelemetry.sdk.metrics import Histogram, MeterProvider
+from opentelemetry.sdk.metrics.export import (
+    AggregationTemporality,
+    InMemoryMetricReader,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.trace import SpanKind, Status, StatusCode
+from opentelemetry.util.http import parse_excluded_urls
+
+from posthog import _metrics_autocapture as metrics_autocapture
+from posthog.client import Client
+from posthog._metrics_autocapture import (
+    DbSpanMetricsProcessor,
+    _BoundedInstrument,
+    _BoundedMeterProvider,
+    start_metrics_autocapture,
+)
+
+FAKE_API_KEY = "phc_test_key"
+
+
+class _Server:
+    def __init__(self):
+        received = self.received = []
+
+        class Handler(BaseHTTPRequestHandler):
+            def _respond(self):
+                length = int(self.headers.get("content-length") or 0)
+                received.append(
+                    {
+                        "path": self.path,
+                        "headers": dict(self.headers),
+                        "body": self.rfile.read(length),
+                    }
+                )
+                self.send_response(200)
+                self.send_header("content-type", "application/json")
+                self.send_header("content-length", "2")
+                self.end_headers()
+                self.wfile.write(b"{}")
+
+            do_GET = _respond
+            do_POST = _respond
+
+            def log_message(self, *args):
+                pass
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        self.port = self.httpd.server_address[1]
+        self.url = f"http://127.0.0.1:{self.port}"
+        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
+
+    def close(self):
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+
+@pytest.fixture
+def posthog_host():
+    server = _Server()
+    yield server
+    server.close()
+
+
+@pytest.fixture
+def app_server():
+    server = _Server()
+    yield server
+    server.close()
+
+
+@pytest.fixture
+def started():
+    handles = []
+    yield handles
+    for handle in handles:
+        handle.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def _reset_autocapture():
+    # A failed test must not leave autocapture running for the tests after it.
+    yield
+    active = metrics_autocapture._active
+    if active is not None:
+        active.shutdown()
+    metrics_autocapture._warned_about_missing_packages = False
+
+
+class _ObservedLock:
+    """A lock that sets ``waited`` when a thread has to wait for it."""
+
+    def __init__(self, waited: threading.Event):
+        self._lock = threading.Lock()
+        self._waited = waited
+
+    def __enter__(self):
+        if not self._lock.acquire(blocking=False):
+            self._waited.set()
+            self._lock.acquire()
+        return self
+
+    def __exit__(self, *exc_info):
+        self._lock.release()
+
+
+@contextmanager
+def _held_by_another_thread(lock):
+    # A forked child has no copy of this thread, so the lock stays held there.
+    held, release = threading.Event(), threading.Event()
+
+    def hold():
+        with lock:
+            held.set()
+            release.wait()
+
+    thread = threading.Thread(target=hold, daemon=True)
+    thread.start()
+    held.wait()
+    try:
+        yield
+    finally:
+        release.set()
+        thread.join()
+
+
+def _child_result(pid, read_fd, timeout=20):
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if os.waitpid(pid, os.WNOHANG) != (0, 0):
+            break
+        time.sleep(0.05)
+    else:
+        os.kill(pid, 9)
+        os.waitpid(pid, 0)
+    result = os.read(read_fd, 16)
+    os.close(read_fd)
+    return result
+
+
+def _metrics_exports(server):
+    return [r for r in server.received if r["path"].endswith("/i/v1/metrics")]
+
+
+def _start(posthog_host, started, reader=None, **overrides):
+    options = dict(
+        host=posthog_host.url,
+        api_key=FAKE_API_KEY,
+        areas={"http": True, "db": True, "runtime": True},
+        service_name="checkout-api",
+        resource_attributes={"deployment.environment": "test"},
+        is_enabled=lambda: True,
+    )
+    options.update(overrides)
+    handle = start_metrics_autocapture(**options, _metric_reader=reader)
+    if handle is not None:
+        started.append(handle)
+    return handle
+
+
+def _points(reader, name):
+    data = reader.get_metrics_data()
+    points = []
+    for resource_metrics in data.resource_metrics if data else []:
+        for scope_metrics in resource_metrics.scope_metrics:
+            for metric in scope_metrics.metrics:
+                if metric.name == name:
+                    points.extend(metric.data.data_points)
+    return points
+
+
+def _names(reader):
+    data = reader.get_metrics_data()
+    return {
+        metric.name
+        for resource_metrics in (data.resource_metrics if data else [])
+        for scope_metrics in resource_metrics.scope_metrics
+        for metric in scope_metrics.metrics
+    }
+
+
+class TestStartMetricsAutocapture:
+    def test_records_http_client_durations_but_not_requests_to_posthog(
+        self, posthog_host, app_server, started
+    ):
+        reader = InMemoryMetricReader()
+        assert _start(posthog_host, started, reader) is not None
+
+        requests.get(f"{app_server.url}/health")
+        requests.post(f"{posthog_host.url}/batch/", data="{}")
+
+        ports = [
+            point.attributes.get("server.port")
+            for point in _points(reader, "http.client.request.duration")
+        ]
+        assert app_server.port in ports
+        assert posthog_host.port not in ports
+
+    def test_records_database_operations_without_the_statement(
+        self, posthog_host, started
+    ):
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader)
+
+        # The instrumentor wraps cursors, which drivers and SQLAlchemy use.
+        connection = sqlite3.connect(":memory:")
+        cursor = connection.cursor()
+        cursor.execute("CREATE TABLE orders (email TEXT)")
+        cursor.execute("SELECT * FROM orders WHERE email = 'a@b.c'")
+        connection.close()
+
+        points = _points(reader, "db.client.operation.duration")
+        operations = {point.attributes.get("db.operation.name") for point in points}
+        assert {"CREATE", "SELECT"} <= operations
+        for point in points:
+            assert point.attributes["db.system.name"] == "sqlite"
+            assert all("a@b.c" not in str(value) for value in point.attributes.values())
+
+    def test_records_runtime_metrics(self, posthog_host, started):
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host,
+            started,
+            reader,
+            areas={"http": False, "db": False, "runtime": True},
+        )
+
+        names = _names(reader)
+        assert "process.cpu.time" in names
+        assert any(name.startswith("cpython.gc.") for name in names)
+        assert "http.client.request.duration" not in names
+
+    def test_exports_otlp_to_posthog_with_the_project_token(
+        self, posthog_host, app_server, started
+    ):
+        handle = _start(posthog_host, started)
+        requests.get(f"{app_server.url}/health")
+
+        handle.force_flush()
+
+        exports = [r for r in posthog_host.received if r["path"] == "/i/v1/metrics"]
+        assert exports
+        headers = {k.lower(): v for k, v in exports[0]["headers"].items()}
+        assert headers["authorization"] == f"Bearer {FAKE_API_KEY}"
+        assert headers["content-type"] == "application/x-protobuf"
+        body = b"".join(r["body"] for r in exports)
+        for expected in (
+            b"http.client.request.duration",
+            b"checkout-api",
+            b"telemetry.distro.name",
+            b"posthog-python",
+            b"deployment.environment",
+        ):
+            assert expected in body
+
+    def test_sends_nothing_while_opted_out(self, posthog_host, app_server, started):
+        handle = _start(posthog_host, started, is_enabled=lambda: False)
+        requests.get(f"{app_server.url}/health")
+
+        handle.force_flush()
+
+        assert [r for r in posthog_host.received if r["path"] == "/i/v1/metrics"] == []
+
+    def test_warns_once_and_returns_none_when_packages_are_missing(
+        self, posthog_host, started
+    ):
+        def missing(name):
+            raise ImportError(f"No module named '{name}'")
+
+        with mock.patch("posthog._metrics_autocapture._import_module", missing):
+            with mock.patch("posthog._metrics_autocapture.log") as log:
+                assert _start(posthog_host, started) is None
+                assert _start(posthog_host, started) is None
+
+        assert log.warning.call_count == 1
+        assert "posthog[metrics]" in str(log.warning.call_args)
+
+    def test_does_not_start_when_opentelemetry_is_already_set_up(
+        self, posthog_host, started
+    ):
+        with mock.patch(
+            "opentelemetry.metrics.get_meter_provider", return_value=MeterProvider()
+        ):
+            with mock.patch("posthog._metrics_autocapture.log") as log:
+                assert _start(posthog_host, started) is None
+
+        assert "already set up" in str(log.warning.call_args)
+
+    def test_runs_once_per_process_and_can_start_again_after_shutdown(
+        self, posthog_host, started
+    ):
+        first = _start(posthog_host, started, InMemoryMetricReader())
+        with mock.patch("posthog._metrics_autocapture.log") as log:
+            assert _start(posthog_host, started) is None
+        assert log.warning.call_count == 1
+
+        first.shutdown()
+        reader = InMemoryMetricReader()
+        assert _start(posthog_host, started, reader) is not None
+
+        connection = sqlite3.connect(":memory:")
+        connection.cursor().execute("SELECT 1")
+        connection.close()
+        assert _points(reader, "db.client.operation.duration")
+
+    def test_does_not_reconfigure_runtime_metrics_that_the_app_set_up(
+        self, posthog_host, started
+    ):
+        # The app's meter provider is private, so autocapture still starts.
+        app_reader = InMemoryMetricReader()
+        app_instrumentor = SystemMetricsInstrumentor(
+            config={"system.cpu.time": ["idle", "user"]}
+        )
+        app_instrumentor.instrument(
+            meter_provider=MeterProvider(metric_readers=[app_reader])
+        )
+        try:
+            assert (
+                _start(
+                    posthog_host,
+                    started,
+                    InMemoryMetricReader(),
+                    areas={"runtime": True},
+                )
+                is not None
+            )
+            assert "system.cpu.time" in _names(app_reader)
+        finally:
+            app_instrumentor.uninstrument()
+
+    def test_a_client_that_starts_during_shutdown_records_http_metrics(
+        self, posthog_host, app_server, started, monkeypatch
+    ):
+        # Set when the other client has started, or has to wait for this shutdown.
+        progress = threading.Event()
+        monkeypatch.setattr(metrics_autocapture, "_lock", _ObservedLock(progress))
+        first = _start(posthog_host, started, areas={"http": True})
+        reader = InMemoryMetricReader()
+        replacement = []
+
+        def start_replacement():
+            replacement.append(
+                _start(posthog_host, started, reader, areas={"http": True})
+            )
+            progress.set()
+
+        thread = threading.Thread(target=start_replacement)
+
+        class StartsAnotherClientDuringShutdown(list):
+            def __iter__(self):
+                thread.start()
+                assert progress.wait(timeout=10)
+                return super().__iter__()
+
+        first._instrumentors = StartsAnotherClientDuringShutdown(first._instrumentors)
+        first.shutdown()
+        thread.join()
+
+        assert replacement[0] is not None
+        requests.get(f"{app_server.url}/health")
+        assert _points(reader, "http.client.request.duration")
+
+    def test_strips_a_trailing_slash_from_the_host(
+        self, posthog_host, app_server, started
+    ):
+        # A reverse proxy path, as in `host="https://example.com/ingest/"`.
+        handle = _start(posthog_host, started, host=f"{posthog_host.url}/ingest/")
+        requests.get(f"{app_server.url}/health")
+
+        handle.force_flush()
+
+        paths = {r["path"] for r in posthog_host.received}
+        assert "/ingest/i/v1/metrics" in paths
+        assert "/ingest//i/v1/metrics" not in paths
+
+    def test_does_not_change_the_process_environment(
+        self, posthog_host, started, monkeypatch
+    ):
+        monkeypatch.delenv("OTEL_SEMCONV_STABILITY_OPT_IN", raising=False)
+        assert _start(posthog_host, started, InMemoryMetricReader()) is not None
+        assert "OTEL_SEMCONV_STABILITY_OPT_IN" not in os.environ
+
+    def test_keeps_an_opt_in_that_the_app_set(self, posthog_host, started, monkeypatch):
+        monkeypatch.setenv("OTEL_SEMCONV_STABILITY_OPT_IN", "http/dup")
+        assert _start(posthog_host, started, InMemoryMetricReader()) is not None
+        assert os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] == "http/dup"
+
+    def test_uses_stable_http_names_when_opentelemetry_read_the_opt_in_before(
+        self, posthog_host, app_server, started, monkeypatch
+    ):
+        # Each OpenTelemetry instrumentor reads the opt-in, but only the first
+        # read in the process counts.
+        stability = _OpenTelemetrySemanticConventionStability
+        monkeypatch.delenv("OTEL_SEMCONV_STABILITY_OPT_IN", raising=False)
+        monkeypatch.setattr(stability, "_initialized", False)
+        monkeypatch.setattr(stability, "_OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING", {})
+        stability._initialize()
+
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, areas={"http": True})
+        requests.get(f"{app_server.url}/health")
+
+        assert _points(reader, "http.client.request.duration")
+        assert not _points(reader, "http.client.duration")
+
+    def test_limits_http_attribute_sets(self, posthog_host, app_server, started):
+        reader = InMemoryMetricReader()
+        with mock.patch.object(metrics_autocapture, "_MAX_ATTRIBUTE_SETS", 1):
+            _start(posthog_host, started, reader)
+
+        requests.get(f"{app_server.url}/a")
+        requests.post(f"{app_server.url}/b", data="{}")
+
+        attributes = [
+            dict(point.attributes)
+            for point in _points(reader, "http.client.request.duration")
+        ]
+        assert len(attributes) == 2
+        assert {"otel.metric.overflow": True} in attributes
+
+    @pytest.mark.skipif(not hasattr(os, "fork"), reason="needs os.fork")
+    @pytest.mark.filterwarnings("ignore:This process .* is multi-threaded")
+    def test_keeps_working_in_a_forked_child(self, posthog_host, app_server, started):
+        reader = InMemoryMetricReader()
+        handle = _start(posthog_host, started, reader)
+        read_fd, write_fd = os.pipe()
+
+        with _held_by_another_thread(metrics_autocapture._lock):
+            pid = os.fork()
+        if pid == 0:  # pragma: no cover - runs in the child
+            result = b"fail"
+            try:
+                runtime = [i for i in handle._instrumentors if hasattr(i, "_proc")]
+                requests.get(f"{app_server.url}/child")
+                if (
+                    runtime
+                    and all(i._proc.pid == os.getpid() for i in runtime)
+                    and _points(reader, "http.client.request.duration")
+                ):
+                    handle.shutdown()
+                    result = b"ok"
+            finally:
+                os.write(write_fd, result)
+                os._exit(0)
+
+        os.close(write_fd)
+        assert _child_result(pid, read_fd) == b"ok"
+        # The child's shutdown does not stop the parent's autocapture.
+        assert metrics_autocapture._active is handle
+
+    @pytest.mark.skipif(not hasattr(os, "fork"), reason="needs os.fork")
+    @pytest.mark.filterwarnings("ignore:This process .* is multi-threaded")
+    def test_exports_from_a_child_forked_during_an_export(self, posthog_host, started):
+        handle = _start(posthog_host, started, export_interval_seconds=3600)
+        read_fd, write_fd = os.pipe()
+
+        # The export thread holds this lock while it sends.
+        with _held_by_another_thread(handle._reader._export_lock):
+            pid = os.fork()
+        if pid == 0:  # pragma: no cover - runs in the child
+            result = b"fail"
+            try:
+                handle.force_flush()
+                result = b"ok"
+            finally:
+                os.write(write_fd, result)
+                os._exit(0)
+
+        os.close(write_fd)
+        assert _child_result(pid, read_fd, timeout=15) == b"ok"
+
+    @pytest.mark.skipif(not hasattr(os, "fork"), reason="needs os.fork")
+    @pytest.mark.filterwarnings("ignore:This process .* is multi-threaded")
+    def test_records_in_a_child_forked_during_a_collection(
+        self, posthog_host, app_server, started
+    ):
+        handle = _start(
+            posthog_host, started, export_interval_seconds=3600, areas={"http": True}
+        )
+        requests.get(f"{app_server.url}/health")
+        consumer = handle._meter_provider._measurement_consumer
+        locks = [consumer._lock]
+        for storage in consumer._reader_storages.values():
+            locks.append(storage._lock)
+            for matches in storage._instrument_view_instrument_matches.values():
+                for match in matches:
+                    locks.append(match._lock)
+                    locks.extend(
+                        aggregation._lock
+                        for aggregation in match._attributes_aggregation.values()
+                    )
+        read_fd, write_fd = os.pipe()
+
+        # Collection and recording hold these locks in other threads.
+        with ExitStack() as stack:
+            for lock in locks:
+                stack.enter_context(_held_by_another_thread(lock))
+            pid = os.fork()
+        if pid == 0:  # pragma: no cover - runs in the child
+            result = b"fail"
+            try:
+                requests.get(f"{app_server.url}/health")
+                handle.force_flush()
+                result = b"ok"
+            finally:
+                os.write(write_fd, result)
+                os._exit(0)
+
+        os.close(write_fd)
+        assert _child_result(pid, read_fd, timeout=15) == b"ok"
+
+    @pytest.mark.parametrize("signal", ["", "METRICS_"])
+    def test_does_not_send_the_apps_otlp_settings_to_posthog(
+        self, posthog_host, app_server, started, monkeypatch, signal
+    ):
+        # These configure the app's own collector, not PostHog.
+        prefix = f"OTEL_EXPORTER_OTLP_{signal}"
+        for key, value in {
+            "HEADERS": "x-vendor-key=vendor-secret",
+            "COMPRESSION": "gzip",
+            "ENDPOINT": "http://127.0.0.1:1/other-collector",
+            "CERTIFICATE": "/other-collector/ca.pem",
+            "CLIENT_CERTIFICATE": "/other-collector/client.pem",
+            "CLIENT_KEY": "/other-collector/client.key",
+            "TIMEOUT": "invalid",
+        }.items():
+            monkeypatch.setenv(prefix + key, value)
+        monkeypatch.setenv(
+            "OTEL_PYTHON_EXPORTER_OTLP_HTTP_METRICS_CREDENTIAL_PROVIDER", "missing"
+        )
+        monkeypatch.setenv(
+            "OTEL_EXPORTER_OTLP_METRICS_DEFAULT_HISTOGRAM_AGGREGATION",
+            "base2_exponential_bucket_histogram",
+        )
+        monkeypatch.setenv(
+            "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE", "CUMULATIVE"
+        )
+        handle = _start(posthog_host, started)
+        requests.get(f"{app_server.url}/health")
+
+        handle.force_flush()
+
+        exports = _metrics_exports(posthog_host)
+        assert exports
+        headers = {k.lower(): v for k, v in exports[0]["headers"].items()}
+        assert "x-vendor-key" not in headers
+        assert "content-encoding" not in headers
+        assert headers["authorization"] == f"Bearer {FAKE_API_KEY}"
+        assert os.environ[prefix + "HEADERS"] == "x-vendor-key=vendor-secret"
+
+        from opentelemetry.proto.collector.metrics.v1.metrics_service_pb2 import (
+            ExportMetricsServiceRequest,
+        )
+
+        data = ExportMetricsServiceRequest.FromString(exports[0]["body"])
+        [duration] = [
+            metric
+            for resource in data.resource_metrics
+            for scope in resource.scope_metrics
+            for metric in scope.metrics
+            if metric.name == "http.client.request.duration"
+        ]
+        assert duration.WhichOneof("data") == "histogram"
+        assert (
+            duration.histogram.aggregation_temporality == AggregationTemporality.DELTA
+        )
+
+    def test_does_not_change_a_concurrent_application_exporter(
+        self, posthog_host, app_server, started, monkeypatch
+    ):
+        from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+        from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
+            OTLPMetricExporter,
+        )
+
+        monkeypatch.setenv("OTEL_EXPORTER_OTLP_ENDPOINT", app_server.url)
+        monkeypatch.setenv("OTEL_EXPORTER_OTLP_HEADERS", "x-vendor-key=vendor-secret")
+        entered, release = threading.Event(), threading.Event()
+        original_init = OTLPMetricExporter.__init__
+
+        def paused_init(exporter, *args, **kwargs):
+            entered.set()
+            assert release.wait(10)
+            original_init(exporter, *args, **kwargs)
+
+        with mock.patch.object(OTLPMetricExporter, "__init__", paused_init):
+            thread = threading.Thread(
+                target=lambda: _start(
+                    posthog_host, started, areas={}, export_interval_seconds=3600
+                )
+            )
+            thread.start()
+            try:
+                assert entered.wait(10)
+                exporter = OTLPLogExporter()
+                try:
+                    assert exporter._endpoint == f"{app_server.url}/v1/logs"
+                    exporter.export(())
+                    assert app_server.received[-1]["headers"]["x-vendor-key"] == (
+                        "vendor-secret"
+                    )
+                finally:
+                    exporter.shutdown()
+            finally:
+                release.set()
+                thread.join(10)
+        assert not thread.is_alive()
+        assert started
+
+    async def test_retained_aiohttp_session_is_inert_after_shutdown(
+        self, posthog_host, app_server, started
+    ):
+        reader = InMemoryMetricReader()
+        handle = _start(posthog_host, started, reader, areas={"http": True})
+        callbacks = []
+        app_config = aiohttp.TraceConfig()
+
+        async def on_start(session, ctx, params):
+            callbacks.append(str(params.url))
+
+        app_config.on_request_start.append(on_start)
+        token = context.attach(baggage.set_baggage("tenant", "synthetic-canary"))
+        try:
+            async with aiohttp.ClientSession(trace_configs=[app_config]) as session:
+                async with session.get(f"{app_server.url}/active") as response:
+                    assert response.status == 200
+                    await response.read()
+                [point] = _points(reader, "http.client.request.duration")
+                assert point.count == 1
+                handle.shutdown()
+                async with session.get(f"{app_server.url}/stopped") as response:
+                    assert response.status == 200
+                    await response.read()
+                assert not session.closed
+                assert baggage.get_baggage("tenant") == "synthetic-canary"
+        finally:
+            context.detach(token)
+        assert callbacks == [f"{app_server.url}/active", f"{app_server.url}/stopped"]
+        for request in app_server.received:
+            headers = {key.lower() for key in request["headers"]}
+            assert not headers.intersection({"baggage", "traceparent", "tracestate"})
+
+    def test_does_not_add_trace_context_to_app_requests(
+        self, posthog_host, app_server, started
+    ):
+        # The spans are never exported, so a downstream service must not see them.
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader)
+
+        requests.get(f"{app_server.url}/health")
+
+        headers = {k.lower() for k in app_server.received[-1]["headers"]}
+        assert "traceparent" not in headers
+        [point] = _points(reader, "http.client.request.duration")
+        assert point.attributes["http.response.status_code"] == 200
+
+    def test_records_nothing_while_disabled(self, posthog_host, app_server, started):
+        # Measurements from the disabled period must not go out once it is enabled.
+        enabled = [False]
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, is_enabled=lambda: enabled[0])
+
+        requests.get(f"{app_server.url}/health")
+        connection = sqlite3.connect(":memory:")
+        connection.cursor().execute("SELECT 1")
+        connection.close()
+        enabled[0] = True
+
+        assert not _points(reader, "http.client.request.duration")
+        assert not _points(reader, "db.client.operation.duration")
+
+    def test_applies_before_send_to_measurements(
+        self, posthog_host, app_server, started
+    ):
+        samples = []
+
+        def before_send(sample):
+            samples.append(dict(sample))
+            if sample["attributes"].get("http.request.method") == "POST":
+                return None
+            sample["attributes"] = {
+                key: value
+                for key, value in sample["attributes"].items()
+                if key != "server.address"
+            }
+            return sample
+
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host, started, reader, areas={"http": True}, before_send=before_send
+        )
+
+        requests.get(f"{app_server.url}/a")
+        requests.post(f"{app_server.url}/b", data="{}")
+
+        points = _points(reader, "http.client.request.duration")
+        assert [point.attributes["http.request.method"] for point in points] == ["GET"]
+        assert "server.address" not in points[0].attributes
+        sample = next(s for s in samples if s["name"] == "http.client.request.duration")
+        assert sample["type"] == "histogram"
+        assert sample["unit"] == "s"
+        assert isinstance(sample["value"], float)
+
+    def test_drops_measurements_when_before_send_raises(
+        self, posthog_host, app_server, started
+    ):
+        def before_send(sample):
+            raise ValueError("bug in the hook")
+
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host, started, reader, areas={"http": True}, before_send=before_send
+        )
+
+        with mock.patch("posthog._metrics_autocapture.log") as log:
+            response = requests.get(f"{app_server.url}/health")
+
+        assert response.status_code == 200
+        assert not _points(reader, "http.client.request.duration")
+        assert log.error.called
+
+    def test_applies_before_send_to_runtime_metrics(self, posthog_host, started):
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host,
+            started,
+            reader,
+            areas={"runtime": True},
+            before_send=lambda s: None if s["name"] == "process.cpu.time" else s,
+        )
+
+        names = _names(reader)
+        assert "process.cpu.time" not in names
+        assert "process.memory.usage" in names
+
+    def test_does_not_record_requests_to_posthog_whatever_the_host_case(
+        self, posthog_host, started
+    ):
+        reader = InMemoryMetricReader()
+        host = f"http://LocalHost:{posthog_host.port}"
+        _start(posthog_host, started, reader, host=host)
+
+        requests.post(f"{host}/batch/", data="{}")
+
+        assert not _points(reader, "http.client.request.duration")
+
+    def test_keeps_the_apps_excluded_urls(
+        self, posthog_host, app_server, started, monkeypatch
+    ):
+        monkeypatch.setenv("OTEL_PYTHON_REQUESTS_EXCLUDED_URLS", "healthz")
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, areas={"http": True})
+
+        requests.get(f"{app_server.url}/healthz")
+        requests.post(f"{app_server.url}/orders", data="{}")
+
+        methods = {
+            point.attributes["http.request.method"]
+            for point in _points(reader, "http.client.request.duration")
+        }
+        assert methods == {"POST"}
+        assert os.environ["OTEL_PYTHON_REQUESTS_EXCLUDED_URLS"] == "healthz"
+
+    def test_does_not_record_httpx_requests_to_posthog(
+        self, posthog_host, app_server, started
+    ):
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, areas={"http": True})
+
+        httpx.post(f"{posthog_host.url}/batch/", content="{}")
+        httpx.get(f"{app_server.url}/health")
+
+        ports = [
+            point.attributes.get("server.port")
+            for point in _points(reader, "http.client.request.duration")
+        ]
+        assert app_server.port in ports
+        assert posthog_host.port not in ports
+
+    async def test_keeps_aiohttp_exclusions_for_sessions_created_after_start(
+        self, posthog_host, app_server, started, monkeypatch
+    ):
+        monkeypatch.setenv("OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS", "healthz")
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, areas={"http": True})
+
+        for _ in range(2):
+            async with aiohttp.ClientSession() as session:
+                for url in (
+                    f"{posthog_host.url}/batch/",
+                    f"{app_server.url}/healthz",
+                    f"{app_server.url}/orders",
+                ):
+                    async with session.get(url) as response:
+                        assert response.status == 200
+                        await response.read()
+
+        points = _points(reader, "http.client.request.duration")
+        assert {point.attributes["server.port"] for point in points} == {
+            app_server.port
+        }
+        assert sum(point.count for point in points) == 2
+        assert os.environ["OTEL_PYTHON_AIOHTTP_CLIENT_EXCLUDED_URLS"] == "healthz"
+
+    def test_flask_restart_does_not_partially_instrument_a_served_app(
+        self, posthog_host, started
+    ):
+        reader = InMemoryMetricReader()
+        first = _start(posthog_host, started, reader, areas={"http": True})
+        app = flask.Flask(__name__)
+        app.add_url_rule("/health", "health", lambda: ("unavailable", 503))
+        client = app.test_client()
+        assert client.get("/health").status_code == 503
+        [point] = _points(reader, "http.server.request.duration")
+        assert point.attributes["http.response.status_code"] == 503
+        first.shutdown()
+        original_wsgi = app.wsgi_app
+        before_request = list(app.before_request_funcs.get(None, []))
+        teardown_request = list(app.teardown_request_funcs.get(None, []))
+
+        for _ in range(3):
+            reader = InMemoryMetricReader()
+            handle = _start(posthog_host, started, reader, areas={"http": True})
+            assert app.wsgi_app is original_wsgi
+            assert not app._is_instrumented_by_opentelemetry
+            assert client.get("/health").status_code == 503
+            assert not _points(reader, "http.server.request.duration")
+            handle.shutdown()
+            assert app.wsgi_app is original_wsgi
+            assert app.before_request_funcs.get(None, []) == before_request
+            assert app.teardown_request_funcs.get(None, []) == teardown_request
+
+        with pytest.raises(AssertionError):
+            app.before_request(lambda: None)
+
+    def test_measures_an_existing_flask_app_restarted_before_its_first_request(
+        self, posthog_host, started
+    ):
+        first = _start(
+            posthog_host, started, InMemoryMetricReader(), areas={"http": True}
+        )
+        app = flask.Flask(__name__)
+        app.add_url_rule("/health", "health", lambda: ("unavailable", 503))
+
+        first.shutdown()
+        reader = InMemoryMetricReader()
+        _start(posthog_host, started, reader, areas={"http": True})
+        assert app.test_client().get("/health").status_code == 503
+
+        [point] = _points(reader, "http.server.request.duration")
+        assert point.count == 1
+        assert point.attributes["http.response.status_code"] == 503
+
+    def test_shutdown_keeps_middleware_that_the_app_added(self, posthog_host, started):
+        samples = []
+
+        def before_send(sample):
+            samples.append(sample["name"])
+            return sample
+
+        handle = _start(
+            posthog_host,
+            started,
+            InMemoryMetricReader(),
+            areas={"http": True},
+            before_send=before_send,
+        )
+        app = flask.Flask(__name__)
+        app.add_url_rule("/secret", "secret", lambda: "secret")
+        protected = app.wsgi_app
+
+        def require_auth(environ, start_response):
+            if environ.get("HTTP_AUTHORIZATION") != "token":
+                start_response("401 Unauthorized", [("Content-Length", "0")])
+                return [b""]
+            return protected(environ, start_response)
+
+        app.wsgi_app = require_auth
+        client = app.test_client()
+        assert client.get("/secret").status_code == 401
+
+        handle.shutdown()
+        samples.clear()
+
+        assert client.get("/secret").status_code == 401
+        assert (
+            client.get("/secret", headers={"Authorization": "token"}).status_code == 200
+        )
+        # The instrumentation left inside the middleware records nothing more.
+        assert samples == []
+
+    def test_does_not_propagate_context_to_other_services(
+        self, posthog_host, app_server, started
+    ):
+        reader = InMemoryMetricReader()
+        handle = _start(posthog_host, started, reader, areas={"http": True})
+        remote = trace.SpanContext(
+            trace_id=0x1234,
+            span_id=0x5678,
+            is_remote=True,
+            trace_flags=trace.TraceFlags(trace.TraceFlags.SAMPLED),
+        )
+        # Baggage and an incoming trace, as a server instrumentor attaches them.
+        current = baggage.set_baggage(
+            "user.email",
+            "a@b.c",
+            trace.set_span_in_context(trace.NonRecordingSpan(remote)),
+        )
+        token = context.attach(current)
+        try:
+            requests.get(f"{app_server.url}/a")
+            httpx.get(f"{app_server.url}/b")
+        finally:
+            context.detach(token)
+
+        for request in app_server.received:
+            headers = {key.lower() for key in request["headers"]}
+            assert not headers & {"traceparent", "tracestate", "baggage"}
+        assert len(_points(reader, "http.client.request.duration")) == 2
+
+        handle.shutdown()
+        requests_instrumentation = sys.modules["opentelemetry.instrumentation.requests"]
+        assert requests_instrumentation.inject is opentelemetry.propagate.inject
+
+    def test_keeps_the_attributes_a_database_span_starts_with(
+        self, posthog_host, started
+    ):
+        # asyncpg passes `db.system` when it starts the span, not later.
+        reader = InMemoryMetricReader()
+        handle = _start(posthog_host, started, reader, areas={"db": True})
+        tracer = handle._tracer_provider.get_tracer(
+            "opentelemetry.instrumentation.asyncpg"
+        )
+
+        tracer.start_span(
+            "SELECT",
+            kind=SpanKind.CLIENT,
+            attributes={"db.system": "postgresql", "db.operation": "SELECT"},
+        ).end()
+
+        [point] = _points(reader, "db.client.operation.duration")
+        assert dict(point.attributes) == {
+            "db.system.name": "postgresql",
+            "db.operation.name": "SELECT",
+        }
+
+    def test_coalesces_concurrent_flushes(self, posthog_host, started, monkeypatch):
+        handle = _start(posthog_host, started, InMemoryMetricReader())
+        exporting = threading.Event()
+        release = threading.Event()
+        flushes = []
+
+        def slow_force_flush(*args, **kwargs):
+            flushes.append(threading.current_thread().name)
+            exporting.set()
+            release.wait(10)
+
+        monkeypatch.setattr(handle._meter_provider, "force_flush", slow_force_flush)
+        waiters = [handle.start_flush()]
+        assert exporting.wait(5)
+        waiters += [handle.start_flush() for _ in range(4)]
+        flushers = [
+            thread
+            for thread in threading.enumerate()
+            if thread.name == "posthog-metrics-autocapture-flush"
+        ]
+        release.set()
+        for wait in waiters:
+            wait(10)
+
+        assert len(flushers) == 1
+        # The calls made during the first flush get one more, so their
+        # measurements are exported too.
+        assert len(flushes) == 2
+
+    def test_a_flush_waits_only_for_the_export_after_it(
+        self, posthog_host, started, monkeypatch
+    ):
+        handle = _start(posthog_host, started, InMemoryMetricReader())
+        exporting = [threading.Event(), threading.Event()]
+        release = [threading.Event(), threading.Event()]
+        exports = []
+
+        def slow_force_flush(*args, **kwargs):
+            export = min(len(exports), 1)
+            exports.append(export)
+            exporting[export].set()
+            release[export].wait(10)
+
+        monkeypatch.setattr(handle._meter_provider, "force_flush", slow_force_flush)
+        first = handle.start_flush()
+        assert exporting[0].wait(5)
+        second = handle.start_flush()
+        release[0].set()
+        assert exporting[1].wait(5)
+
+        # The second export is still running, but it is not for the first call.
+        began = time.monotonic()
+        assert first(5)
+        assert time.monotonic() - began < 2
+        assert not second(0.1)
+        release[1].set()
+        assert second(5)
+
+    def test_normalizes_attributes_from_before_send(
+        self, posthog_host, app_server, started
+    ):
+        def before_send(sample):
+            sample["attributes"] = {
+                **sample["attributes"],
+                "deployment.tags": ["blue", "canary"],
+                "owner": {"team": "core"},
+            }
+            return sample
+
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host, started, reader, areas={"http": True}, before_send=before_send
+        )
+
+        response = requests.get(f"{app_server.url}/health")
+
+        assert response.status_code == 200
+        [point] = _points(reader, "http.client.request.duration")
+        assert point.attributes["deployment.tags"] == ("blue", "canary")
+        assert "owner" not in point.attributes
+
+    def test_normalizes_runtime_attributes_from_before_send(
+        self, posthog_host, started
+    ):
+        def before_send(sample):
+            sample["attributes"] = {
+                **sample["attributes"],
+                "deployment.tags": ["blue"],
+                "owner": {"team": "core"},
+            }
+            return sample
+
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host,
+            started,
+            reader,
+            areas={"runtime": True},
+            before_send=before_send,
+        )
+
+        [point, *_] = _points(reader, "process.thread.count")
+        assert point.attributes["deployment.tags"] == ("blue",)
+        assert "owner" not in point.attributes
+
+    def test_cleans_up_when_startup_fails(self, posthog_host, started):
+        real_entry_points = metrics_autocapture.entry_points
+
+        def failing_entry_points(**kwargs):
+            yield from real_entry_points(**kwargs)
+            raise RuntimeError("broken plugin")
+
+        def reader_threads():
+            return [
+                thread
+                for thread in threading.enumerate()
+                if thread.name == "OtelPeriodicExportingMetricReader"
+            ]
+
+        before = len(reader_threads())
+        with mock.patch.object(
+            metrics_autocapture, "entry_points", failing_entry_points
+        ):
+            with mock.patch("posthog._metrics_autocapture.log"):
+                assert _start(posthog_host, started) is None
+
+        assert len(reader_threads()) == before
+        assert not RequestsInstrumentor().is_instrumented_by_opentelemetry
+        assert metrics_autocapture._active is None
+
+    def test_uses_the_same_resource_as_the_manual_metrics_api(
+        self, posthog_host, started, monkeypatch
+    ):
+        monkeypatch.setenv("OTEL_SERVICE_NAME", "from-env")
+        monkeypatch.setenv("OTEL_RESOURCE_ATTRIBUTES", "team=from-env")
+        reader = InMemoryMetricReader()
+        _start(
+            posthog_host,
+            started,
+            reader,
+            areas={"runtime": True},
+            service_name=None,
+            resource_attributes={},
+        )
+
+        resource = reader.get_metrics_data().resource_metrics[0].resource.attributes
+        assert resource["service.name"] == "unknown_service"
+        assert "team" not in resource
+        assert resource["telemetry.distro.name"] == "posthog-python"
+
+    def test_shutdown_twice_is_safe(self, posthog_host, started):
+        handle = _start(posthog_host, started, InMemoryMetricReader())
+
+        handle.shutdown()
+        handle.shutdown()
+
+        assert metrics_autocapture._active is None
+
+
+class TestPostHogUrlExclusion:
+    def _excluded(self, host, url):
+        pattern = metrics_autocapture._posthog_url_pattern(host)
+        return parse_excluded_urls(pattern).url_disabled(url)
+
+    def test_matches_the_host_with_or_without_its_default_port(self):
+        assert self._excluded(
+            "https://us.i.posthog.com", "https://us.i.posthog.com:443/batch/"
+        )
+        assert self._excluded(
+            "https://us.i.posthog.com:443", "https://us.i.posthog.com/batch/"
+        )
+        assert self._excluded("http://LocalHost:8000", "http://localhost:8000/batch/")
+
+    def test_does_not_match_other_hosts_ports_or_paths(self):
+        assert not self._excluded(
+            "https://us.i.posthog.com", "https://us.i.posthog.com.evil.com/"
+        )
+        assert not self._excluded(
+            "https://us.i.posthog.com", "https://us.i.posthog.com:8443/batch/"
+        )
+        assert not self._excluded(
+            "https://example.com/ingest", "https://example.com/ingestion"
+        )
+
+    def test_keeps_a_comma_in_the_host_path(self):
+        assert self._excluded(
+            "https://example.com/a,b", "https://example.com/a,b/i/v1/metrics"
+        )
+        assert not self._excluded("https://example.com/a,b", "https://unrelated.com/b")
+
+
+class TestBoundedMeterProvider:
+    def test_drops_raw_url_and_client_attributes(self):
+        # As the Tornado instrumentor records them: raw paths can hold tokens.
+        reader = InMemoryMetricReader()
+        provider = _BoundedMeterProvider(MeterProvider(metric_readers=[reader]), 10)
+        histogram = provider.get_meter("test").create_histogram("http.server.duration")
+
+        histogram.record(
+            1,
+            {
+                "http.method": "GET",
+                "http.status_code": 200,
+                "http.host": "shop.example",
+                "http.target": "/reset/private-token",
+                "http.url": "https://shop.example/reset/private-token?email=a@b.c",
+                "url.full": "https://shop.example/reset/private-token",
+                "url.path": "/reset/private-token",
+                "url.query": "email=a@b.c",
+                "http.client_ip": "203.0.113.7",
+                "client.address": "203.0.113.7",
+                "net.peer.ip": "203.0.113.7",
+                "http.user_agent": "Mozilla/5.0",
+                "user_agent.original": "Mozilla/5.0",
+                "http.request.header.authorization": ("Bearer secret",),
+                "http.response.header.set_cookie": ("session=secret",),
+            },
+        )
+
+        [point] = _points(reader, "http.server.duration")
+        assert dict(point.attributes) == {
+            "http.method": "GET",
+            "http.status_code": 200,
+            "http.host": "shop.example",
+        }
+
+    def test_never_raises_into_the_instrumented_call(self):
+        class BrokenInstrument:
+            def record(self, *args, **kwargs):
+                raise TypeError("broken")
+
+        _BoundedInstrument(BrokenInstrument(), 10).record(1.0, {"a": "b"})
+
+    def test_shares_the_limit_across_wrappers_of_the_same_instrument(self):
+        reader = InMemoryMetricReader(
+            preferred_temporality={Histogram: AggregationTemporality.DELTA}
+        )
+        native = MeterProvider(metric_readers=[reader], shutdown_on_exit=False)
+        provider = _BoundedMeterProvider(native, 2)
+        try:
+            for batch in (("a", "b"), ("c", "d")):
+                for host in batch:
+                    histogram = provider.get_meter("test").create_histogram("duration")
+                    histogram.record(1, {"server.address": host})
+                points = _points(reader, "duration")
+                assert sum(point.count for point in points) == 2
+                if batch == ("c", "d"):
+                    assert [dict(point.attributes) for point in points] == [
+                        {"otel.metric.overflow": True}
+                    ]
+        finally:
+            native.shutdown()
+
+    def test_sends_new_attribute_sets_to_an_overflow_series(self):
+        # Delta, as autocapture exports: the SDK still keeps each attribute set.
+        reader = InMemoryMetricReader(
+            preferred_temporality={Histogram: AggregationTemporality.DELTA}
+        )
+        provider = _BoundedMeterProvider(MeterProvider(metric_readers=[reader]), 2)
+        histogram = provider.get_meter("test").create_histogram("duration")
+
+        for _ in range(2):
+            for host in ("a", "b", "c", "d"):
+                histogram.record(1, {"server.address": host})
+            points = _points(reader, "duration")
+            assert sorted(
+                (str(dict(point.attributes)), point.count) for point in points
+            ) == [
+                ("{'otel.metric.overflow': True}", 2),
+                ("{'server.address': 'a'}", 1),
+                ("{'server.address': 'b'}", 1),
+            ]
+
+
+class TestDbSpanMetricsProcessor:
+    def _record(self, scope, kind=SpanKind.CLIENT, attributes=None, error=False):
+        reader = InMemoryMetricReader()
+        meter = MeterProvider(metric_readers=[reader]).get_meter("test")
+        provider = TracerProvider()
+        provider.add_span_processor(DbSpanMetricsProcessor(meter))
+        span = provider.get_tracer(scope).start_span("query", kind=kind)
+        span.set_attributes(attributes or {})
+        if error:
+            span.set_status(Status(StatusCode.ERROR))
+        span.end()
+        return _points(reader, "db.client.operation.duration")
+
+    def test_turns_a_driver_span_into_a_duration_histogram(self):
+        points = self._record(
+            "opentelemetry.instrumentation.psycopg2",
+            attributes={
+                "db.system": "postgresql",
+                "db.statement": "select * from orders where id = 7",
+                "db.name": "shop",
+                "net.peer.name": "db.internal",
+                "net.peer.port": 5432,
+            },
+        )
+
+        assert len(points) == 1
+        assert dict(points[0].attributes) == {
+            "db.system.name": "postgresql",
+            "db.operation.name": "SELECT",
+            "db.namespace": "shop",
+            "server.address": "db.internal",
+            "server.port": 5432,
+        }
+
+    def test_marks_failures(self):
+        points = self._record(
+            "opentelemetry.instrumentation.pymongo",
+            attributes={"db.system": "mongodb", "db.operation": "find"},
+            error=True,
+        )
+
+        assert dict(points[0].attributes) == {
+            "db.system.name": "mongodb",
+            "db.operation.name": "find",
+            "error.type": "_OTHER",
+        }
+
+    def test_keeps_only_the_first_word_of_the_operation(self):
+        points = self._record(
+            "opentelemetry.instrumentation.psycopg",
+            attributes={
+                "db.system": "postgresql",
+                "db.operation.name": "SELECT orders",
+            },
+        )
+
+        assert points[0].attributes["db.operation.name"] == "SELECT"
+
+    def test_skips_orm_layers_and_other_spans(self):
+        # SQLAlchemy wraps a driver span, so counting it would count the query twice.
+        assert (
+            self._record(
+                "opentelemetry.instrumentation.sqlalchemy",
+                attributes={"db.system": "postgresql"},
+            )
+            == []
+        )
+        assert (
+            self._record(
+                "opentelemetry.instrumentation.psycopg2",
+                kind=SpanKind.SERVER,
+                attributes={"db.system": "postgresql"},
+            )
+            == []
+        )
+        assert (
+            self._record(
+                "opentelemetry.instrumentation.requests",
+                attributes={"http.request.method": "GET"},
+            )
+            == []
+        )
+
+
+class TestClientOption:
+    def test_starts_with_metrics_autocapture_and_stops_on_shutdown(
+        self, posthog_host, started
+    ):
+        client = Client(
+            FAKE_API_KEY, host=posthog_host.url, metrics={"autocapture": True}
+        )
+        with mock.patch("posthog._metrics_autocapture.log"):
+            assert _start(posthog_host, started) is None
+
+        client.shutdown()
+        assert _start(posthog_host, started) is not None
+
+    def test_does_not_start_by_default_or_when_disabled(self, posthog_host, started):
+        plain = Client(FAKE_API_KEY, host=posthog_host.url)
+        disabled = Client(
+            FAKE_API_KEY,
+            host=posthog_host.url,
+            disabled=True,
+            metrics={"autocapture": True},
+        )
+
+        assert _start(posthog_host, started) is not None
+        plain.shutdown()
+        disabled.shutdown()
+
+    def test_sends_nothing_when_send_is_false(self, posthog_host, app_server):
+        client = Client(
+            FAKE_API_KEY,
+            host=posthog_host.url,
+            send=False,
+            metrics={"autocapture": True},
+        )
+        try:
+            assert client._metrics_autocapture is not None
+            requests.get(f"{app_server.url}/health")
+            client._metrics_autocapture.force_flush()
+            assert [
+                r for r in posthog_host.received if r["path"] == "/i/v1/metrics"
+            ] == []
+        finally:
+            client.shutdown()
+
+    def test_passes_the_metrics_options_to_autocapture(self, posthog_host):
+        hook_calls = []
+
+        def before_send(sample):
+            hook_calls.append(configured._lifecycle_callback_context.get())
+            return {**sample, "value": 2.0}
+
+        with mock.patch(
+            "posthog._metrics_autocapture.start_metrics_autocapture", return_value=None
+        ) as start:
+            configured = Client(
+                FAKE_API_KEY,
+                host=posthog_host.url,
+                metrics={
+                    "autocapture": {"runtime": False},
+                    "service_name": "billing-api",
+                    "service_version": "1.2.3",
+                    "environment": "staging",
+                    "resource_attributes": {
+                        "deployment.environment": "prod",
+                        "team": "core",
+                    },
+                    "flush_interval": 30,
+                    "before_send": before_send,
+                },
+            )
+            configured.shutdown()
+            Client(
+                FAKE_API_KEY,
+                host=posthog_host.url,
+                metrics={
+                    "autocapture": True,
+                    "service_name": "billing-api",
+                    "resource_attributes": {"service.name": "billing-worker"},
+                },
+            ).shutdown()
+
+        first, second = (call.kwargs for call in start.call_args_list)
+        assert first["host"] == posthog_host.url
+        assert first["api_key"] == FAKE_API_KEY
+        assert first["areas"] == {"http": True, "db": True, "runtime": False}
+        assert first["service_name"] == "billing-api"
+        assert first["resource_attributes"] == {
+            "deployment.environment": "prod",
+            "team": "core",
+            "service.version": "1.2.3",
+        }
+        assert first["export_interval_seconds"] == 30
+        # The hook runs as an SDK callback, so a flush() it calls is deferred.
+        assert first["before_send"]({"name": "m", "value": 1.0}) == {
+            "name": "m",
+            "value": 2.0,
+        }
+        assert hook_calls == [True]
+        assert second["areas"] == {"http": True, "db": True, "runtime": True}
+        assert second["service_name"] == "billing-worker"
+        assert second["export_interval_seconds"] == 10
+        assert second["before_send"] is None
+
+    @pytest.mark.parametrize("flush_interval", [-1, "5", True])
+    def test_ignores_an_invalid_flush_interval(self, posthog_host, flush_interval):
+        client = Client(
+            FAKE_API_KEY,
+            host=posthog_host.url,
+            metrics={"autocapture": True, "flush_interval": flush_interval},
+        )
+        try:
+            assert client._metrics_autocapture is not None
+            assert client._metrics_autocapture._reader._export_interval_millis == 10_000
+        finally:
+            client.shutdown()
+
+    def test_flush_exports_autocaptured_metrics(self, posthog_host, app_server):
+        client = Client(
+            FAKE_API_KEY,
+            host=posthog_host.url,
+            metrics={"autocapture": True, "flush_interval": 3600},
+        )
+        try:
+            requests.get(f"{app_server.url}/health")
+            client.flush()
+            assert _metrics_exports(posthog_host)
+        finally:
+            client.shutdown()
+
+    def test_shutdown_twice_is_safe(self, posthog_host):
+        client = Client(
+            FAKE_API_KEY, host=posthog_host.url, metrics={"autocapture": True}
+        )
+
+        client.shutdown()
+        client.shutdown()
+
+        assert metrics_autocapture._active is None
+
+    def test_exit_does_not_wait_for_an_unreachable_host(self):
+        # Accepts connections and never answers, like a host behind a dead proxy.
+        server = socket.socket()
+        server.bind(("127.0.0.1", 0))
+        server.listen(16)
+        script = textwrap.dedent(
+            f"""
+            from posthog.client import Client
+            Client(
+                "{FAKE_API_KEY}",
+                host="http://127.0.0.1:{server.getsockname()[1]}",
+                metrics={{"autocapture": {{"http": False, "db": False}}}},
+            )
+            """
+        )
+        try:
+            began = time.monotonic()
+            subprocess.run(
+                [sys.executable, "-c", script],
+                check=True,
+                timeout=60,
+                cwd=Path(__file__).resolve().parents[2],
+            )
+            elapsed = time.monotonic() - began
+        finally:
+            server.close()
+
+        assert elapsed < 6
+
+    def test_sync_client_is_collectable_after_shutdown(self, posthog_host):
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-c",
+                textwrap.dedent(
+                    f"""
+                    import gc
+                    import weakref
+                    from posthog.client import Client
+
+                    client = Client(
+                        "{FAKE_API_KEY}", host="{posthog_host.url}", sync_mode=True,
+                        metrics={{"autocapture": {{"db": True, "http": False, "runtime": False}}}},
+                    )
+                    assert client._metrics_autocapture is not None
+                    client.shutdown()
+                    ref = weakref.ref(client)
+                    del client
+                    gc.collect()
+                    assert ref() is None, "The exit callback retains the closed client"
+                    """
+                ),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=20,
+        )
+        assert result.returncode == 0, result.stderr
+
+    def test_sync_mode_exports_the_last_window_at_exit(self, posthog_host):
+        script = textwrap.dedent(
+            f"""
+            import sqlite3
+            from posthog.client import Client
+            Client(
+                "{FAKE_API_KEY}",
+                host="{posthog_host.url}",
+                sync_mode=True,
+                metrics={{
+                    "autocapture": {{"http": False, "runtime": False}},
+                    "flush_interval": 3600,
+                }},
+            )
+            connection = sqlite3.connect(":memory:")
+            connection.cursor().execute("SELECT 1")
+            connection.close()
+            """
+        )
+        subprocess.run(
+            [sys.executable, "-c", script],
+            check=True,
+            timeout=60,
+            cwd=Path(__file__).resolve().parents[2],
+        )
+
+        exports = _metrics_exports(posthog_host)
+        assert exports
+        assert b"db.client.operation.duration" in b"".join(r["body"] for r in exports)
+
+    def test_before_send_can_call_flush(self, posthog_host):
+        # Runtime callbacks run while OpenTelemetry holds its collection lock.
+        script = textwrap.dedent(
+            f"""
+            import os, threading
+            from posthog.client import Client
+
+            def before_send(sample):
+                if sample["name"] == "process.cpu.time":
+                    client.flush(timeout_seconds=None)
+                return sample
+
+            client = Client(
+                "{FAKE_API_KEY}",
+                host="{posthog_host.url}",
+                metrics={{
+                    "autocapture": {{"http": False, "db": False}},
+                    "flush_interval": 3600,
+                    "before_send": before_send,
+                }},
+            )
+            flush = threading.Thread(
+                target=client.flush, kwargs={{"timeout_seconds": None}}, daemon=True
+            )
+            flush.start()
+            flush.join(10)
+            print("deadlock" if flush.is_alive() else "ok", flush=True)
+            os._exit(0)
+            """
+        )
+        result = subprocess.run(
+            [sys.executable, "-c", script],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=Path(__file__).resolve().parents[2],
+        )
+
+        assert result.stdout.strip() == "ok"
+        assert _metrics_exports(posthog_host)
+
+    def _run_django_script(self, posthog_host, body):
+        script = textwrap.dedent(
+            f"""
+            import os
+            os.environ.pop("DJANGO_SETTINGS_MODULE", None)
+            from django.conf import settings
+            from posthog.client import Client
+
+            def start():
+                return Client(
+                    "{FAKE_API_KEY}",
+                    host="{posthog_host.url}",
+                    metrics={{"autocapture": {{"db": False, "runtime": False}}}},
+                )
+            """
+        ) + textwrap.dedent(body)
+        return subprocess.run(
+            [sys.executable, "-c", script],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=Path(__file__).resolve().parents[2],
+        )
+
+    def test_does_not_configure_django_settings(self, posthog_host):
+        # Django apps that configure settings in code do it after imports.
+        result = self._run_django_script(
+            posthog_host,
+            """
+            client = start()
+            settings.configure(DEBUG=True)
+            print("configured", settings.DEBUG)
+            client.shutdown()
+            """,
+        )
+
+        assert result.stdout.strip() == "configured True", result.stderr[-2000:]
+
+    def test_instruments_django_once_its_settings_are_configured(self, posthog_host):
+        # As in AppConfig.ready().
+        result = self._run_django_script(
+            posthog_host,
+            """
+            settings.configure(MIDDLEWARE=[])
+            client = start()
+            print("middleware", settings.MIDDLEWARE)
+            client.shutdown()
+            """,
+        )
+
+        assert "_DjangoMiddleware" in result.stdout, result.stderr[-2000:]
+
+    def test_a_flush_from_before_send_does_not_repeat(self, posthog_host):
+        # Each autocapture export runs the hook again.
+        script = textwrap.dedent(
+            f"""
+            import os, time
+            from posthog.client import Client
+
+            def before_send(sample):
+                if sample["name"] == "process.cpu.time":
+                    client.flush()
+                return sample
+
+            client = Client(
+                "{FAKE_API_KEY}",
+                host="{posthog_host.url}",
+                metrics={{
+                    "autocapture": {{"http": False, "db": False}},
+                    "flush_interval": 3600,
+                    "before_send": before_send,
+                }},
+            )
+            client.flush(timeout_seconds=5)
+            time.sleep(2)
+            os._exit(0)
+            """
+        )
+        subprocess.run(
+            [sys.executable, "-c", script],
+            check=True,
+            timeout=60,
+            cwd=Path(__file__).resolve().parents[2],
+        )
+
+        assert len(_metrics_exports(posthog_host)) == 1
+
+    def test_starts_on_a_later_module_setup(self, posthog_host, monkeypatch):
+        # A Django ready() hook can set the option after setup() already ran.
+        import posthog
+
+        monkeypatch.setattr(posthog, "default_client", None)
+        monkeypatch.setattr(posthog, "api_key", FAKE_API_KEY)
+        monkeypatch.setattr(posthog, "host", posthog_host.url)
+        monkeypatch.setattr(posthog, "metrics", None)
+        client = posthog.setup()
+        try:
+            assert client._metrics_autocapture is None
+            monkeypatch.setattr(posthog, "metrics", {"autocapture": True})
+            assert posthog.setup() is client
+            assert client._metrics_autocapture is not None
+        finally:
+            client.shutdown()
+
+    def test_module_setup_tries_to_start_once(self, posthog_host, started, monkeypatch):
+        import posthog
+
+        assert _start(posthog_host, started, InMemoryMetricReader()) is not None
+        monkeypatch.setattr(posthog, "default_client", None)
+        monkeypatch.setattr(posthog, "api_key", FAKE_API_KEY)
+        monkeypatch.setattr(posthog, "host", posthog_host.url)
+        monkeypatch.setattr(posthog, "metrics", {"autocapture": True})
+        with mock.patch("posthog._metrics_autocapture.log") as log:
+            client = posthog.setup()
+            posthog.setup()
+            posthog.setup()
+        client.shutdown()
+
+        assert log.warning.call_count == 1
diff --git a/pyproject.toml b/pyproject.toml
index bab09689c..d98183b74 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,6 +49,18 @@ otel = [
     "opentelemetry-sdk>=1.20.0",
     "opentelemetry-exporter-otlp-proto-http>=1.20.0",
 ]
+# Metrics autocapture (`metrics={"autocapture": True}`). Library instrumentors
+# (requests, Django, psycopg, ...) are separate packages: `opentelemetry-bootstrap
+# -a install` adds the ones that match the installed libraries.
+# 0.58b0 is the first release with the `process.*` and `cpython.gc.*` names that
+# runtime autocapture configures, and 0.60b0 the first in which the httpx
+# instrumentor (installed at the same version) excludes URLs.
+metrics = [
+    "opentelemetry-sdk>=1.39.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.39.0",
+    "opentelemetry-instrumentation>=0.60b0",
+    "opentelemetry-instrumentation-system-metrics>=0.60b0",
+]
 dev = [
     "django-stubs",
     "griffe",
@@ -100,6 +112,15 @@ test = [
     "fastmcp>=2.0",
     "opentelemetry-sdk>=1.20.0",
     "opentelemetry-exporter-otlp-proto-http>=1.20.0",
+    "opentelemetry-instrumentation>=0.60b0",
+    "opentelemetry-instrumentation-system-metrics>=0.60b0",
+    "opentelemetry-instrumentation-requests>=0.60b0",
+    "opentelemetry-instrumentation-sqlite3>=0.60b0",
+    "opentelemetry-instrumentation-wsgi>=0.60b0",
+    "opentelemetry-instrumentation-flask>=0.60b0",
+    "opentelemetry-instrumentation-httpx>=0.60b0",
+    "opentelemetry-instrumentation-aiohttp-client>=0.60b0",
+    "opentelemetry-instrumentation-django>=0.60b0",
     "pytest-bdd>=8.1.0",
     "zstandard>=0.23.0",
     # gevent 25.4.1+ replaces queue.Queue, exercising the compatibility path.
diff --git a/uv.lock b/uv.lock
index a0f072074..1d3359b29 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2786,6 +2786,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/b2/d1413681ff43e13ac9860df27e1226d3199ab0b97b352ceea41abcc660a5/opentelemetry_instrumentation-0.66b1-py3-none-any.whl", hash = "sha256:4c4aa14dc9a24a02325a9d4c42c4d0208dbb1374c2b1b8fe6c9392d59f3e1008", size = 36904, upload-time = "2026-10-06T17:35:11.663Z" },
 ]
 
+[[package]]
+name = "opentelemetry-instrumentation-aiohttp-client"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/85/fe/634d77a0109df609eb290d172ab57e45fe35a1ef2c277f3e1908267acaa1/opentelemetry_instrumentation_aiohttp_client-0.66b1.tar.gz", hash = "sha256:6f853dadc53916fd6af41413bcb627b3e36c4a01b581e03b61b2f8eb6031d69f", size = 18849, upload-time = "2026-10-06T17:36:12.072Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/30/dd352a722a4b928b22363df249b38b6d173173d36b2eab6d04770fd7d348/opentelemetry_instrumentation_aiohttp_client-0.66b1-py3-none-any.whl", hash = "sha256:bb3d412ae30e83e0692c8e9b600c5990bdab736c7c048847461b4567d504078d", size = 13610, upload-time = "2026-10-06T17:35:13.651Z" },
+]
+
 [[package]]
 name = "opentelemetry-instrumentation-celery"
 version = "0.66b1"
@@ -2800,6 +2816,129 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/73/b7597b2fede14cafe7122d1028bd6f648d9c1e049a61ab36481a4ed4f0df/opentelemetry_instrumentation_celery-0.66b1-py3-none-any.whl", hash = "sha256:145b5eece41331141edc8f454984238b05b107d7ead928b49e7a1916d5e48e99", size = 13480, upload-time = "2026-10-06T17:35:25.828Z" },
 ]
 
+[[package]]
+name = "opentelemetry-instrumentation-dbapi"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/b4/35c682a3a5762547cab6ac1d0f6e66a4e549cbbb852862903bb1523036fe/opentelemetry_instrumentation_dbapi-0.66b1.tar.gz", hash = "sha256:715be3080f644de2314d84388a73571acdbeca85bfbc7dc682f214c88cc18022", size = 19990, upload-time = "2026-10-06T17:36:22.281Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/77/89/7f2ccd50975b66b2977a31bb489a2f0205b7fd033fc99046dcfa001c4252/opentelemetry_instrumentation_dbapi-0.66b1-py3-none-any.whl", hash = "sha256:a38043a8a907a321ae6b838f778ad19c8e78c0bfc2f336d6d30c5fdce112e88d", size = 14706, upload-time = "2026-10-06T17:35:28.831Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-django"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-wsgi" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/88/d0acbd7916aa3040a36486cedb60aa77c129c7029446fa6a00207345695c/opentelemetry_instrumentation_django-0.66b1.tar.gz", hash = "sha256:85b56193b6ce7b8db9c280c3ade4a4991601abc9ada4734c8911971423fd521f", size = 25233, upload-time = "2026-10-06T17:36:22.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5b/c3/2739c248b60b2802b9e51d2a3373269f0ca3e16059ea4f1ca7370502118c/opentelemetry_instrumentation_django-0.66b1-py3-none-any.whl", hash = "sha256:23d1052940a025ae1dac70849b998cf9ba66731fa2b7e58254ab7dac5539a989", size = 18914, upload-time = "2026-10-06T17:35:30.052Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-flask"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-wsgi" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/fc/c1a692ceb7ed56818f2f4f88044b5a0895b6666da954dbd566fdf265195b/opentelemetry_instrumentation_flask-0.66b1.tar.gz", hash = "sha256:10f788aff95236f0dbaaa066687283bf6345bb3c77bbb437f0fb67cb6222d5eb", size = 23876, upload-time = "2026-10-06T17:36:25.763Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/52/65/7aa45ca677c51afb185bcd5e7ed121c84b07b2c566a72948a9e56fd16ae7/opentelemetry_instrumentation_flask-0.66b1-py3-none-any.whl", hash = "sha256:2933e71b94cc9e8e943e648d872fd3dead9cdb61295dc6deffd5d6fa8f27a39b", size = 14961, upload-time = "2026-10-06T17:35:34.002Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-httpx"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/50/41544799b043d14fdfa6fe62fa2518eaba22793fce03e9abde930b92e671/opentelemetry_instrumentation_httpx-0.66b1.tar.gz", hash = "sha256:5865a72c68098c85955a271ab8744b480a36e3ee492d35b8cadb93c7c4dbb618", size = 26637, upload-time = "2026-10-06T17:36:27.265Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4f/c6/e5682b1bfb320b32505e88255c34ae1e99fe9fb220cc465c244e91967eac/opentelemetry_instrumentation_httpx-0.66b1-py3-none-any.whl", hash = "sha256:0342a4002c6dbc6c4bf22cc7e698f50f5c8b77f63325c6f40c94ab87e016bf4d", size = 17723, upload-time = "2026-10-06T17:35:36.501Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-requests"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/62/dcca0b7a2008675056040c61b70d37b5a24439613c7822068908ad3255ae/opentelemetry_instrumentation_requests-0.66b1.tar.gz", hash = "sha256:28578f72e68e3a5be3226c618ac9570ed360ef1dd22d5d6e0721c6905a4ccc67", size = 17985, upload-time = "2026-10-06T17:36:37.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/01/98e9bb7fef12784cd19811e454cf25bce4d774fd3e46b3f5fd2bce237075/opentelemetry_instrumentation_requests-0.66b1-py3-none-any.whl", hash = "sha256:7ba17d984a2bd876b88bf0aafcca27b5e3ff4c1821e0fe07641e380a3cf3a3a2", size = 13320, upload-time = "2026-10-06T17:35:52.477Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-sqlite3"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-dbapi" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/25/54/742ab70c78a1589c29f5513fd5097845b2c2fda58390bbff0f6e1af2601a/opentelemetry_instrumentation_sqlite3-0.66b1.tar.gz", hash = "sha256:e5d672a347deac385a71fb52d556ea443e2f3cc51eac05cac8f0a739cac0bb38", size = 9019, upload-time = "2026-10-06T17:36:38.74Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/6a/c36552844c4e3545da7b2931213256c0717665c7d92246a4fe66e088fd9b/opentelemetry_instrumentation_sqlite3-0.66b1-py3-none-any.whl", hash = "sha256:f282b712f56186c36d592d4ab856d978bc7dd60f4b10500113da8c9eb45ff9bc", size = 8526, upload-time = "2026-10-06T17:35:54.362Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-system-metrics"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "psutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d6/81/ab8cabaf45c5248fa88a0d0d3acea4483c105d76cd6c849654ebdab16f92/opentelemetry_instrumentation_system_metrics-0.66b1.tar.gz", hash = "sha256:b0fccbc1aecf35c182431a035ec4809b8f9607eec692243cf70f23b3bda51231", size = 17207, upload-time = "2026-10-06T17:36:40.518Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/fd/ea072c512d65ba4054b02c8b7080cf1b362761d4727ee6c1f36dce53328d/opentelemetry_instrumentation_system_metrics-0.66b1-py3-none-any.whl", hash = "sha256:0654b41eb6db3c2f9ad9979487afcc6f461e5b35df282f0a11d0f465e906d967", size = 13913, upload-time = "2026-10-06T17:35:57.01Z" },
+]
+
+[[package]]
+name = "opentelemetry-instrumentation-wsgi"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-semantic-conventions" },
+    { name = "opentelemetry-util-http" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/7a/a1ba86d95f849db8f41ffd03c7cb302559ef091d76cff78baddd4ad19205/opentelemetry_instrumentation_wsgi-0.66b1.tar.gz", hash = "sha256:ce803d8e828e75d7225c25a618b692cbd4687a11be64356308ed1feab0f70bab", size = 19527, upload-time = "2026-10-06T17:36:44.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/4f/17f06b0dc7c542c482b1d3f7f1d0925046f7e156fb39c255634b3c4f526a/opentelemetry_instrumentation_wsgi-0.66b1-py3-none-any.whl", hash = "sha256:8c86390c32fe8d0924b3541f292122d3a2ba6c3accc2bcbcc73ae985ee8e799e", size = 13752, upload-time = "2026-10-06T17:36:03.166Z" },
+]
+
 [[package]]
 name = "opentelemetry-proto"
 version = "1.45.1"
@@ -2839,6 +2978,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bc/14/67f8aa798857f8cf686f515bf93d9bb877ce952ddc8efae0fa25b45ce0d6/opentelemetry_semantic_conventions-0.66b1-py3-none-any.whl", hash = "sha256:d4cddeb4315490b35213f55e2bdc9ac54bb1e4d318927475bed62b35545e581b", size = 206279, upload-time = "2026-10-06T17:32:56.103Z" },
 ]
 
+[[package]]
+name = "opentelemetry-util-http"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/b5/df4b61da899f6ebdffdbdf0c8b0f3189ee57151694ccd5b7d50ee2906241/opentelemetry_util_http-0.66b1.tar.gz", hash = "sha256:047dea1a628031f857a5a32261dc0e955bc162d39993ed1cffb8f2cff5ba8a62", size = 11586, upload-time = "2026-10-06T17:36:46.572Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/9b/c77ecaea79ba0de1a11e7f06a7f5eea7043ec23f1860dcf5f03536698e4c/opentelemetry_util_http-0.66b1-py3-none-any.whl", hash = "sha256:8f443d7abcaf29c4a07b373bbd31b5b39132c0ed3c27d015a59dc0323d5b1c58", size = 8387, upload-time = "2026-10-06T17:36:06.984Z" },
+]
+
 [[package]]
 name = "orjson"
 version = "3.11.7"
@@ -3088,6 +3236,12 @@ dev = [
 langchain = [
     { name = "langchain" },
 ]
+metrics = [
+    { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-system-metrics" },
+    { name = "opentelemetry-sdk" },
+]
 otel = [
     { name = "opentelemetry-exporter-otlp-proto-http" },
     { name = "opentelemetry-sdk" },
@@ -3116,7 +3270,16 @@ test = [
     { name = "mcp" },
     { name = "openai-agents" },
     { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-instrumentation" },
+    { name = "opentelemetry-instrumentation-aiohttp-client" },
     { name = "opentelemetry-instrumentation-celery" },
+    { name = "opentelemetry-instrumentation-django" },
+    { name = "opentelemetry-instrumentation-flask" },
+    { name = "opentelemetry-instrumentation-httpx" },
+    { name = "opentelemetry-instrumentation-requests" },
+    { name = "opentelemetry-instrumentation-sqlite3" },
+    { name = "opentelemetry-instrumentation-system-metrics" },
+    { name = "opentelemetry-instrumentation-wsgi" },
     { name = "opentelemetry-sdk" },
     { name = "parameterized" },
     { name = "pydantic" },
@@ -3171,9 +3334,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -3201,7 +3377,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
@@ -3338,6 +3514,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
 ]
 
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
+    { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },
+    { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+    { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
 [[package]]
 name = "py-key-value-aio"
 version = "0.4.5"

From ce03e476bb0256bed4f3b6745ebb50fc3dead745 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 10:29:55 +0000
Subject: [PATCH 130/245] chore: Release v7.80.0 [skip ci]

---
 .sampo/changesets/metrics-autocapture.md | 13 -------------
 openfeature-provider/CHANGELOG.md        |  6 ++++++
 openfeature-provider/pyproject.toml      |  2 +-
 posthog/CHANGELOG.md                     | 15 +++++++++++++++
 posthog/version.py                       |  2 +-
 pyproject.toml                           |  2 +-
 uv.lock                                  |  4 ++--
 7 files changed, 26 insertions(+), 18 deletions(-)
 delete mode 100644 .sampo/changesets/metrics-autocapture.md

diff --git a/.sampo/changesets/metrics-autocapture.md b/.sampo/changesets/metrics-autocapture.md
deleted file mode 100644
index d562f8862..000000000
--- a/.sampo/changesets/metrics-autocapture.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add `metrics={"autocapture": True}` (alpha): HTTP, database and runtime metrics from the official OpenTelemetry instrumentations, with no instrumentation code. Install `posthog[metrics]` and run `opentelemetry-bootstrap -a install` to add the instrumentors for your libraries. Create the client before your web app (Django: in `AppConfig.ready()`): apps created earlier are not measured. For Flask, use module lookup as below, or import the `Flask` class only after the client starts; an earlier `from flask import Flask` alias is not instrumented. Already-served Flask apps are not re-instrumented after shutdown; create a new app for a replacement client. Autocapture does not start when the app already set up OpenTelemetry; export those metrics to PostHog instead. Raw URLs and paths, client addresses, user agents and captured headers are never recorded. `metrics.before_send` also applies to autocaptured measurements: it can change their value and attributes, or drop them.
-
-```python
-import flask
-from posthog import Posthog
-
-client = Posthog("phc_...", metrics={"autocapture": True})
-app = flask.Flask(__name__)
-```
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index b06b99036..5abeea9b6 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.131 — 2026-10-29
+
+### Patch changes
+
+- Updated dependencies: posthog@7.80.0
+
 ## 0.1.130 — 2026-10-28
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index fd4301834..448fad153 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.130"
+version = "0.1.131"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 063d59e0c..08fe11661 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,20 @@
 # posthog
 
+## 7.80.0 — 2026-10-29
+
+### Minor changes
+
+- [febb3ed](https://github.com/posthog/posthog-python/commit/febb3ed2f1584e68c05c73625becbdd18fe5f944) Add `metrics={"autocapture": True}` (alpha): HTTP, database and runtime metrics from the official OpenTelemetry instrumentations, with no instrumentation code. Install `posthog[metrics]` and run `opentelemetry-bootstrap -a install` to add the instrumentors for your libraries. Create the client before your web app (Django: in `AppConfig.ready()`): apps created earlier are not measured. For Flask, use module lookup as below, or import the `Flask` class only after the client starts; an earlier `from flask import Flask` alias is not instrumented. Already-served Flask apps are not re-instrumented after shutdown; create a new app for a replacement client. Autocapture does not start when the app already set up OpenTelemetry; export those metrics to PostHog instead. Raw URLs and paths, client addresses, user agents and captured headers are never recorded. `metrics.before_send` also applies to autocaptured measurements: it can change their value and attributes, or drop them.
+  
+  ```python
+  import flask
+  from posthog import Posthog
+  
+  client = Posthog("phc_...", metrics={"autocapture": True})
+  app = flask.Flask(__name__)
+  ```
+   — Thanks @DanielVisca!
+
 ## 7.79.0 — 2026-10-28
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index c6c3571ef..d9cc0934b 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.79.0"
+VERSION = "7.80.0"
diff --git a/pyproject.toml b/pyproject.toml
index d98183b74..762e40614 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.79.0"
+version = "7.80.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 1d3359b29..17ec8ce2a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.130"
+version = "0.1.131"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3202,7 +3202,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.79.0"
+version = "7.80.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 175fac6d6e4fdbb179ead60869ed5a864ea1f6ff Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 10:30:02 +0000
Subject: [PATCH 131/245] Update generated references

---
 .../posthog-python-references-7.80.0.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    4 +-
 2 files changed, 3550 insertions(+), 2 deletions(-)
 create mode 100644 references/posthog-python-references-7.80.0.json

diff --git a/references/posthog-python-references-7.80.0.json b/references/posthog-python-references-7.80.0.json
new file mode 100644
index 000000000..cecc19693
--- /dev/null
+++ b/references/posthog-python-references-7.80.0.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.80.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index a58eca355..cecc19693 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.79.0",
+    "version": "7.80.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -1001,7 +1001,7 @@
         {
           "id": "flush",
           "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
           "details": "",
           "category": null,
           "params": [

From 1625f4fbc1809d7a19b34354ad2df2a0e016928f Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:39:42 -0400
Subject: [PATCH 132/245] fix(ai): handle None and NOT_GIVEN stream_options
 without mutating the caller's dict (#1144)

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .sampo/changesets/openai-stream-options.md |  5 ++
 posthog/ai/openai/openai.py                |  9 ++-
 posthog/ai/openai/openai_async.py          |  9 ++-
 posthog/test/ai/openai/test_openai.py      | 64 ++++++++++++++++++++++
 4 files changed, 81 insertions(+), 6 deletions(-)
 create mode 100644 .sampo/changesets/openai-stream-options.md

diff --git a/.sampo/changesets/openai-stream-options.md b/.sampo/changesets/openai-stream-options.md
new file mode 100644
index 000000000..8d5fb4778
--- /dev/null
+++ b/.sampo/changesets/openai-stream-options.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Fix streaming OpenAI chat completions when `stream_options` is `None` or `NOT_GIVEN` (it raised a `TypeError`), and stop adding `include_usage` to the `stream_options` dict the caller passed in.
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index ccdf6e69a..d8654f090 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -389,9 +389,12 @@ def _create_streaming(
     ):
         start_time = time.time()
         state = _ChatCompletionsStreamState()
-        if "stream_options" not in kwargs:
-            kwargs["stream_options"] = {}
-        kwargs["stream_options"]["include_usage"] = True
+        # The caller's dict is left alone, and None / NOT_GIVEN mean "no options"
+        stream_options = kwargs.get("stream_options")
+        kwargs["stream_options"] = {
+            **(stream_options if isinstance(stream_options, dict) else {}),
+            "include_usage": True,
+        }
         response = self._original.create(**kwargs)
 
         def generator():
diff --git a/posthog/ai/openai/openai_async.py b/posthog/ai/openai/openai_async.py
index 07e0de670..95a898139 100644
--- a/posthog/ai/openai/openai_async.py
+++ b/posthog/ai/openai/openai_async.py
@@ -393,9 +393,12 @@ async def _create_streaming(
         start_time = time.time()
         state = _ChatCompletionsStreamState()
 
-        if "stream_options" not in kwargs:
-            kwargs["stream_options"] = {}
-        kwargs["stream_options"]["include_usage"] = True
+        # The caller's dict is left alone, and None / NOT_GIVEN mean "no options"
+        stream_options = kwargs.get("stream_options")
+        kwargs["stream_options"] = {
+            **(stream_options if isinstance(stream_options, dict) else {}),
+            "include_usage": True,
+        }
         response = await self._original.create(**kwargs)
 
         async def async_generator():
diff --git a/posthog/test/ai/openai/test_openai.py b/posthog/test/ai/openai/test_openai.py
index a0a550191..6a5f34cf4 100644
--- a/posthog/test/ai/openai/test_openai.py
+++ b/posthog/test/ai/openai/test_openai.py
@@ -7,6 +7,7 @@
 import pytest
 
 try:
+    from openai import NOT_GIVEN
     from openai.types.chat import ChatCompletion, ChatCompletionMessage
     from openai.types.chat.chat_completion import Choice
     from openai.types.chat.chat_completion_chunk import (
@@ -460,6 +461,33 @@ def test_embeddings(mock_client, mock_embedding_response):
         assert isinstance(props["$ai_latency"], float)
 
 
+@pytest.mark.parametrize("stream_options", [None, NOT_GIVEN, {"foo": "bar"}])
+def test_streaming_stream_options_are_not_mutated(
+    mock_client, streaming_tool_call_chunks, stream_options
+):
+    captured = {}
+
+    def mock_create(self, **kwargs):
+        captured["kwargs"] = kwargs
+        return iter(streaming_tool_call_chunks)
+
+    with patch("openai.resources.chat.completions.Completions.create", new=mock_create):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+        stream = client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+            stream_options=stream_options,
+        )
+        list(stream)
+
+    sent = captured["kwargs"]["stream_options"]
+    assert sent["include_usage"] is True
+    if isinstance(stream_options, dict):
+        assert sent == {"foo": "bar", "include_usage": True}
+        assert stream_options == {"foo": "bar"}
+
+
 def test_groups(mock_client, mock_openai_response):
     with patch(
         "openai.resources.chat.completions.Completions.create",
@@ -1421,6 +1449,42 @@ async def chunk_iterable():
     assert isinstance(props["$ai_latency"], float)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("stream_options", [None, NOT_GIVEN, {"foo": "bar"}])
+async def test_async_streaming_stream_options_are_not_mutated(
+    mock_client, streaming_tool_call_chunks, stream_options
+):
+    captured = {}
+
+    async def mock_create(self, **kwargs):
+        captured["kwargs"] = kwargs
+
+        async def chunk_iterable():
+            for chunk in streaming_tool_call_chunks:
+                yield chunk
+
+        return chunk_iterable()
+
+    with patch(
+        "openai.resources.chat.completions.AsyncCompletions.create", new=mock_create
+    ):
+        client = AsyncOpenAI(api_key="test-key", posthog_client=mock_client)
+        stream = await client.chat.completions.create(
+            model="gpt-4",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+            stream_options=stream_options,
+        )
+        async for _ in stream:
+            pass
+
+    sent = captured["kwargs"]["stream_options"]
+    assert sent["include_usage"] is True
+    if isinstance(stream_options, dict):
+        assert sent == {"foo": "bar", "include_usage": True}
+        assert stream_options == {"foo": "bar"}
+
+
 @pytest.mark.asyncio
 async def test_async_embeddings_create(mock_client, mock_embedding_response):
     mock_create = AsyncMock(return_value=mock_embedding_response)

From 58d69e3127134967e317ee29e25ad70de3909b79 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:41:36 +0000
Subject: [PATCH 133/245] chore: Release v7.80.1 [skip ci]

---
 .sampo/changesets/openai-stream-options.md | 5 -----
 openfeature-provider/CHANGELOG.md          | 6 ++++++
 openfeature-provider/pyproject.toml        | 2 +-
 posthog/CHANGELOG.md                       | 6 ++++++
 posthog/version.py                         | 2 +-
 pyproject.toml                             | 2 +-
 uv.lock                                    | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/openai-stream-options.md

diff --git a/.sampo/changesets/openai-stream-options.md b/.sampo/changesets/openai-stream-options.md
deleted file mode 100644
index 8d5fb4778..000000000
--- a/.sampo/changesets/openai-stream-options.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Fix streaming OpenAI chat completions when `stream_options` is `None` or `NOT_GIVEN` (it raised a `TypeError`), and stop adding `include_usage` to the `stream_options` dict the caller passed in.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 5abeea9b6..b80b9e7ce 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.132 — 2026-10-29
+
+### Patch changes
+
+- Updated dependencies: posthog@7.80.1
+
 ## 0.1.131 — 2026-10-29
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 448fad153..e887d001c 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.131"
+version = "0.1.132"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 08fe11661..72393f860 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.80.1 — 2026-10-29
+
+### Patch changes
+
+- [1625f4f](https://github.com/posthog/posthog-python/commit/1625f4fbc1809d7a19b34354ad2df2a0e016928f) Fix streaming OpenAI chat completions when `stream_options` is `None` or `NOT_GIVEN` (it raised a `TypeError`), and stop adding `include_usage` to the `stream_options` dict the caller passed in. — Thanks @pcbeingused333!
+
 ## 7.80.0 — 2026-10-29
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index d9cc0934b..f32b8b91a 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.80.0"
+VERSION = "7.80.1"
diff --git a/pyproject.toml b/pyproject.toml
index 762e40614..325e59829 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.80.0"
+version = "7.80.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 17ec8ce2a..71efd9dc8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.131"
+version = "0.1.132"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3202,7 +3202,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.80.0"
+version = "7.80.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From e4f43a4bf81b7e8c6ec151f53086964c88e39854 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:41:41 +0000
Subject: [PATCH 134/245] Update generated references

---
 .../posthog-python-references-7.80.1.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.80.1.json

diff --git a/references/posthog-python-references-7.80.1.json b/references/posthog-python-references-7.80.1.json
new file mode 100644
index 000000000..841a5b2d4
--- /dev/null
+++ b/references/posthog-python-references-7.80.1.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.80.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index cecc19693..841a5b2d4 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.80.0",
+    "version": "7.80.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From ad1b1cb1e2052621d979cfdccb4870d6b4b31613 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 29 Oct 2026 07:51:52 -0400
Subject: [PATCH 135/245] fix(ai): capture an $ai_embedding event when an
 OpenAI embeddings call fails (#1143)

Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .sampo/changesets/openai-embeddings-error.md |  5 ++
 posthog/ai/openai/_embeddings.py             | 19 +++++++-
 posthog/ai/openai/openai.py                  | 18 ++++++-
 posthog/ai/openai/openai_async.py            | 18 ++++++-
 posthog/test/ai/openai/test_openai.py        | 50 ++++++++++++++++++++
 5 files changed, 106 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/openai-embeddings-error.md

diff --git a/.sampo/changesets/openai-embeddings-error.md b/.sampo/changesets/openai-embeddings-error.md
new file mode 100644
index 000000000..678639cc3
--- /dev/null
+++ b/.sampo/changesets/openai-embeddings-error.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Capture an `$ai_embedding` event with `$ai_is_error` and `$ai_error` when an OpenAI `embeddings.create()` call fails, in the sync and async wrappers. Before, a failed embeddings call left no event.
diff --git a/posthog/ai/openai/_embeddings.py b/posthog/ai/openai/_embeddings.py
index 8cdb04d33..b34c0c358 100644
--- a/posthog/ai/openai/_embeddings.py
+++ b/posthog/ai/openai/_embeddings.py
@@ -1,6 +1,12 @@
 from typing import Any, Dict, Optional
 
-from ..utils import _capture_ai_event, finalize_ai_content, with_privacy_mode
+from ..utils import (
+    _capture_ai_event,
+    _format_ai_error,
+    _get_http_status,
+    finalize_ai_content,
+    with_privacy_mode,
+)
 
 
 def _capture_embedding_event(
@@ -15,6 +21,7 @@ def _capture_embedding_event(
     properties: Optional[Dict[str, Any]],
     privacy_mode: bool,
     groups: Optional[Dict[str, Any]],
+    error: Optional[BaseException] = None,
 ) -> None:
     """Build and capture telemetry shared by sync and async embedding wrappers."""
     usage = getattr(response, "usage", None)
@@ -28,7 +35,7 @@ def _capture_embedding_event(
             privacy_mode,
             finalize_ai_content(request_kwargs.get("input"), posthog_client),
         ),
-        "$ai_http_status": 200,
+        "$ai_http_status": _get_http_status(error) if error is not None else 200,
         # Omitted when the provider never reported a count: absent means
         # unknown, 0 is a report of nothing.
         **({"$ai_input_tokens": input_tokens} if input_tokens is not None else {}),
@@ -36,6 +43,14 @@ def _capture_embedding_event(
         "$ai_trace_id": trace_id,
         "$ai_base_url": str(base_url),
         **(properties or {}),
+        **(
+            {
+                "$ai_is_error": True,
+                "$ai_error": _format_ai_error(posthog_client, privacy_mode, error),
+            }
+            if error is not None
+            else {}
+        ),
     }
 
     if distinct_id is None:
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index d8654f090..1bdcdeb6f 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -498,7 +498,23 @@ def create(
         )
 
         start_time = time.time()
-        response = self._original.create(**kwargs)
+        try:
+            response = self._original.create(**kwargs)
+        except Exception as exc:
+            _capture_embedding_event(
+                posthog_client=self._client._ph_client,
+                base_url=self._client.base_url,
+                response=None,
+                request_kwargs=kwargs,
+                latency=time.time() - start_time,
+                distinct_id=posthog_distinct_id,
+                trace_id=posthog_trace_id,
+                properties=posthog_properties,
+                privacy_mode=posthog_privacy_mode,
+                groups=posthog_groups,
+                error=exc,
+            )
+            raise
         end_time = time.time()
 
         _capture_embedding_event(
diff --git a/posthog/ai/openai/openai_async.py b/posthog/ai/openai/openai_async.py
index 95a898139..1282e1ddf 100644
--- a/posthog/ai/openai/openai_async.py
+++ b/posthog/ai/openai/openai_async.py
@@ -502,7 +502,23 @@ async def create(
         )
 
         start_time = time.time()
-        response = await self._original.create(**kwargs)
+        try:
+            response = await self._original.create(**kwargs)
+        except Exception as exc:
+            _capture_embedding_event(
+                posthog_client=self._client._ph_client,
+                base_url=self._client.base_url,
+                response=None,
+                request_kwargs=kwargs,
+                latency=time.time() - start_time,
+                distinct_id=posthog_distinct_id,
+                trace_id=posthog_trace_id,
+                properties=posthog_properties,
+                privacy_mode=posthog_privacy_mode,
+                groups=posthog_groups,
+                error=exc,
+            )
+            raise
         end_time = time.time()
 
         _capture_embedding_event(
diff --git a/posthog/test/ai/openai/test_openai.py b/posthog/test/ai/openai/test_openai.py
index 6a5f34cf4..dcbfde242 100644
--- a/posthog/test/ai/openai/test_openai.py
+++ b/posthog/test/ai/openai/test_openai.py
@@ -488,6 +488,33 @@ def mock_create(self, **kwargs):
         assert stream_options == {"foo": "bar"}
 
 
+def test_embeddings_error(mock_client):
+    with patch(
+        "openai.resources.embeddings.Embeddings.create",
+        side_effect=Exception("Test error"),
+    ):
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+        with pytest.raises(Exception, match="Test error"):
+            client.embeddings.create(
+                model="text-embedding-3-small",
+                input="Hello world",
+                posthog_distinct_id="test-id",
+            )
+
+    assert mock_client.capture.call_count == 1
+
+    call_args = mock_client.capture.call_args[1]
+    props = call_args["properties"]
+    assert call_args["distinct_id"] == "test-id"
+    assert call_args["event"] == "$ai_embedding"
+    assert props["$ai_model"] == "text-embedding-3-small"
+    assert props["$ai_input"] == "Hello world"
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "Test error"
+    assert props["$ai_http_status"] == 0
+    assert "$ai_input_tokens" not in props
+
+
 def test_groups(mock_client, mock_openai_response):
     with patch(
         "openai.resources.chat.completions.Completions.create",
@@ -1449,6 +1476,29 @@ async def chunk_iterable():
     assert isinstance(props["$ai_latency"], float)
 
 
+@pytest.mark.asyncio
+async def test_async_embeddings_error(mock_client):
+    mock_create = AsyncMock(side_effect=Exception("Test error"))
+
+    with patch("openai.resources.embeddings.AsyncEmbeddings.create", new=mock_create):
+        client = AsyncOpenAI(api_key="test-key", posthog_client=mock_client)
+        with pytest.raises(Exception, match="Test error"):
+            await client.embeddings.create(
+                model="text-embedding-3-small",
+                input="Hello world",
+                posthog_distinct_id="test-id",
+            )
+
+    assert mock_client.capture.call_count == 1
+
+    call_args = mock_client.capture.call_args[1]
+    props = call_args["properties"]
+    assert call_args["event"] == "$ai_embedding"
+    assert props["$ai_is_error"] is True
+    assert props["$ai_error"] == "Test error"
+    assert props["$ai_http_status"] == 0
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize("stream_options", [None, NOT_GIVEN, {"foo": "bar"}])
 async def test_async_streaming_stream_options_are_not_mutated(

From 9a9d8067157f922c55503b53a68e9a220d568351 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:53:09 +0000
Subject: [PATCH 136/245] chore: Release v7.80.2 [skip ci]

---
 .sampo/changesets/openai-embeddings-error.md | 5 -----
 openfeature-provider/CHANGELOG.md            | 6 ++++++
 openfeature-provider/pyproject.toml          | 2 +-
 posthog/CHANGELOG.md                         | 6 ++++++
 posthog/version.py                           | 2 +-
 pyproject.toml                               | 2 +-
 uv.lock                                      | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/openai-embeddings-error.md

diff --git a/.sampo/changesets/openai-embeddings-error.md b/.sampo/changesets/openai-embeddings-error.md
deleted file mode 100644
index 678639cc3..000000000
--- a/.sampo/changesets/openai-embeddings-error.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Capture an `$ai_embedding` event with `$ai_is_error` and `$ai_error` when an OpenAI `embeddings.create()` call fails, in the sync and async wrappers. Before, a failed embeddings call left no event.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index b80b9e7ce..5c089f077 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.133 — 2026-10-29
+
+### Patch changes
+
+- Updated dependencies: posthog@7.80.2
+
 ## 0.1.132 — 2026-10-29
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index e887d001c..41b8c489b 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.132"
+version = "0.1.133"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 72393f860..00de658b6 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.80.2 — 2026-10-29
+
+### Patch changes
+
+- [ad1b1cb](https://github.com/posthog/posthog-python/commit/ad1b1cb1e2052621d979cfdccb4870d6b4b31613) Capture an `$ai_embedding` event with `$ai_is_error` and `$ai_error` when an OpenAI `embeddings.create()` call fails, in the sync and async wrappers. Before, a failed embeddings call left no event. — Thanks @pcbeingused333!
+
 ## 7.80.1 — 2026-10-29
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index f32b8b91a..e4c192ab3 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.80.1"
+VERSION = "7.80.2"
diff --git a/pyproject.toml b/pyproject.toml
index 325e59829..4d11eab27 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.80.1"
+version = "7.80.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 71efd9dc8..5d053e840 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.132"
+version = "0.1.133"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3202,7 +3202,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.80.1"
+version = "7.80.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From ad79bd03c268eb02f4b17ab8fc21998a1e3bf2fe Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 11:53:16 +0000
Subject: [PATCH 137/245] Update generated references

---
 .../posthog-python-references-7.80.2.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.80.2.json

diff --git a/references/posthog-python-references-7.80.2.json b/references/posthog-python-references-7.80.2.json
new file mode 100644
index 000000000..d8cd45066
--- /dev/null
+++ b/references/posthog-python-references-7.80.2.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.80.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 841a5b2d4..d8cd45066 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.80.1",
+    "version": "7.80.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 4d6e44766175f80fbbf538ab4369b1f3916f05f7 Mon Sep 17 00:00:00 2001
From: mosafariuk <mosafariuk@gmail.com>
Date: Thu, 29 Oct 2026 14:00:47 +0000
Subject: [PATCH 138/245] fix(ai): report OpenAI Agents cached tokens (#1102)

* fix(ai): report OpenAI Agents cached and reasoning tokens

The Agents SDK nests cached input and reasoning tokens under the usage
details fields: input_tokens_details/output_tokens_details on generation
span usage and on the Responses usage object of response spans. The
processor read flat keys that the SDK never sets, so both were always
dropped. Read the nested fields, keeping the flat keys for custom models.

* fix(ai): declare inclusive cache reporting for nested Agents usage

OpenAI-shaped usage counts cached tokens inside input_tokens. Declare
$ai_cache_reporting_exclusive: False when the cache count comes from the
nested usage details, as the Node Agents processor does, so the cost backend
does not infer exclusive reporting from a Claude model name served through an
OpenAI-compatible endpoint. Flat custom-model keys keep their own convention,
and a caller-supplied value still takes precedence.

* fix(ai): don't forward inclusive Agents reasoning tokens

OpenAI-compatible providers such as OpenRouter count reasoning inside
completion_tokens, while the cost backend adds reasoning on top for Gemini
model names, so forwarding the nested count priced reasoning twice. Keep
the original flat reasoning_tokens key only; cached tokens are unchanged.
---
 .../openai-agents-cache-reasoning-tokens.md   |   5 +
 posthog/ai/openai_agents/processor.py         |  52 +++++-
 .../test/ai/openai_agents/test_processor.py   | 157 ++++++++++++++++++
 3 files changed, 211 insertions(+), 3 deletions(-)
 create mode 100644 .sampo/changesets/openai-agents-cache-reasoning-tokens.md

diff --git a/.sampo/changesets/openai-agents-cache-reasoning-tokens.md b/.sampo/changesets/openai-agents-cache-reasoning-tokens.md
new file mode 100644
index 000000000..342cc3257
--- /dev/null
+++ b/.sampo/changesets/openai-agents-cache-reasoning-tokens.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Report cached input tokens from OpenAI Agents generation and response spans, which nest them under the usage details fields, and declare them inclusive.
diff --git a/posthog/ai/openai_agents/processor.py b/posthog/ai/openai_agents/processor.py
index e3e8450e2..951dd95e2 100644
--- a/posthog/ai/openai_agents/processor.py
+++ b/posthog/ai/openai_agents/processor.py
@@ -47,6 +47,27 @@ def _parse_iso_timestamp(iso_str: Optional[str]) -> Optional[float]:
         return None
 
 
+def _usage_detail(usage: Any, details_keys: tuple, key: str) -> Optional[int]:
+    """Read a token count nested under a usage details field.
+
+    Agents span usage is a dict (generation spans) or an OpenAI usage object
+    (response spans), with details under ``input_tokens_details``/
+    ``output_tokens_details`` (Responses) or ``prompt_tokens_details``/
+    ``completion_tokens_details`` (Chat Completions).
+    """
+
+    def get(container: Any, name: str) -> Any:
+        if isinstance(container, dict):
+            return container.get(name)
+        return getattr(container, name, None)
+
+    for details_key in details_keys:
+        value = get(get(usage, details_key), key)
+        if isinstance(value, int):
+            return value
+    return None
+
+
 class PostHogTracingProcessor(TracingProcessor):
     """
     A tracing processor that sends OpenAI Agents SDK traces to PostHog.
@@ -547,11 +568,27 @@ def _handle_generation_span(
             ),
         }
 
-        # Add optional token fields if present
+        # Add optional token fields if present. The Agents SDK nests cached
+        # tokens under the usage details fields; flat keys are kept for custom
+        # models. Nested reasoning is not forwarded: compatible providers count
+        # it inside the output total, and the cost backend would add it again.
         if usage.get("reasoning_tokens"):
             properties["$ai_reasoning_tokens"] = usage["reasoning_tokens"]
-        if usage.get("cache_read_input_tokens"):
-            properties["$ai_cache_read_input_tokens"] = usage["cache_read_input_tokens"]
+        cache_read_tokens = usage.get("cache_read_input_tokens")
+        if not cache_read_tokens:
+            cache_read_tokens = _usage_detail(
+                usage,
+                ("input_tokens_details", "prompt_tokens_details"),
+                "cached_tokens",
+            )
+            if cache_read_tokens:
+                # OpenAI-shaped usage counts cached tokens inside input_tokens.
+                # Say so explicitly: the cost backend otherwise infers exclusive
+                # reporting from Claude model names served through compatible
+                # endpoints. A caller-supplied value still takes precedence.
+                properties["$ai_cache_reporting_exclusive"] = False
+        if cache_read_tokens:
+            properties["$ai_cache_read_input_tokens"] = cache_read_tokens
         if usage.get("cache_creation_input_tokens"):
             properties["$ai_cache_creation_input_tokens"] = usage[
                 "cache_creation_input_tokens"
@@ -727,6 +764,15 @@ def _handle_response_span(
         if total_cost_usd is not None:
             properties["$ai_total_cost_usd"] = total_cost_usd
 
+        if usage:
+            cache_read_tokens = _usage_detail(
+                usage, ("input_tokens_details",), "cached_tokens"
+            )
+            if cache_read_tokens:
+                properties["$ai_cache_read_input_tokens"] = cache_read_tokens
+                # Responses input_tokens include cached tokens.
+                properties["$ai_cache_reporting_exclusive"] = False
+
         # Extract output content from response
         if response:
             output_items = getattr(response, "output", None)
diff --git a/posthog/test/ai/openai_agents/test_processor.py b/posthog/test/ai/openai_agents/test_processor.py
index 3cbc6d276..36e9a5803 100644
--- a/posthog/test/ai/openai_agents/test_processor.py
+++ b/posthog/test/ai/openai_agents/test_processor.py
@@ -288,6 +288,163 @@ def test_generation_span_with_reasoning_tokens(
         call_kwargs = mock_client.capture.call_args[1]
         assert call_kwargs["properties"]["$ai_reasoning_tokens"] == 400
 
+    def test_generation_span_reads_nested_cache_tokens(
+        self, processor, mock_client, mock_span
+    ):
+        """The Agents SDK nests cached and reasoning tokens under the usage
+        details fields of generation span usage."""
+        from agents.usage import Usage, model_usage_to_span_usage
+        from openai.types.responses.response_usage import (
+            InputTokensDetails,
+            OutputTokensDetails,
+        )
+
+        usage = Usage(
+            requests=1,
+            input_tokens=100,
+            output_tokens=50,
+            total_tokens=150,
+            input_tokens_details=InputTokensDetails(
+                cached_tokens=60, cache_write_tokens=0
+            ),
+            output_tokens_details=OutputTokensDetails(reasoning_tokens=40),
+        )
+        mock_span.span_data = GenerationSpanData(
+            model="gpt-5-mini", usage=model_usage_to_span_usage(usage)
+        )
+
+        processor.on_span_start(mock_span)
+        processor.on_span_end(mock_span)
+
+        props = mock_client.capture.call_args[1]["properties"]
+        assert props["$ai_input_tokens"] == 100
+        assert props["$ai_cache_read_input_tokens"] == 60
+        assert props["$ai_output_tokens"] == 50
+        # Inclusive in output_tokens; forwarding it would be counted twice.
+        assert "$ai_reasoning_tokens" not in props
+        assert props["$ai_cache_reporting_exclusive"] is False
+
+    def test_response_span_reads_cache_tokens(self, processor, mock_client, mock_span):
+        """Response spans carry the OpenAI Responses usage object, with cached
+        and reasoning tokens in its details fields."""
+        from openai.types.responses import Response
+
+        response = Response.model_validate(
+            {
+                "id": "resp_123",
+                "object": "response",
+                "created_at": 0,
+                "model": "gpt-5-mini",
+                "status": "completed",
+                "parallel_tool_calls": True,
+                "tool_choice": "auto",
+                "tools": [],
+                "output": [],
+                "usage": {
+                    "input_tokens": 100,
+                    "output_tokens": 50,
+                    "total_tokens": 150,
+                    "input_tokens_details": {
+                        "cached_tokens": 60,
+                        "cache_write_tokens": 0,
+                    },
+                    "output_tokens_details": {"reasoning_tokens": 40},
+                },
+            }
+        )
+        mock_span.span_data = ResponseSpanData(response=response, input="Hi")
+
+        processor.on_span_start(mock_span)
+        processor.on_span_end(mock_span)
+
+        props = mock_client.capture.call_args[1]["properties"]
+        assert props["$ai_input_tokens"] == 100
+        assert props["$ai_cache_read_input_tokens"] == 60
+        assert props["$ai_output_tokens"] == 50
+        # Inclusive in output_tokens; forwarding it would be counted twice.
+        assert "$ai_reasoning_tokens" not in props
+        assert props["$ai_cache_reporting_exclusive"] is False
+
+    def test_cached_compatible_claude_usage_is_declared_inclusive(self):
+        """A Claude model behind an OpenAI-compatible endpoint reports inclusive
+        cached tokens. Without an explicit convention, the cost backend infers
+        exclusive reporting from the model name and overcounts input cost."""
+        from agents import set_trace_processors
+        from agents.tracing import generation_span, trace
+
+        client = MagicMock(privacy_mode=False, enable_full_ai_capture=False)
+        set_trace_processors([])
+        processor = instrument(client, distinct_id="review-user")
+        try:
+            with trace("compatible-model"):
+                with generation_span(
+                    model="anthropic/claude-sonnet-4.6",
+                    usage={
+                        "input_tokens": 10339,
+                        "output_tokens": 60,
+                        "input_tokens_details": {"cached_tokens": 10318},
+                    },
+                ):
+                    pass
+            properties = next(
+                call.kwargs["properties"]
+                for call in client.capture.call_args_list
+                if call.kwargs["event"] == "$ai_generation"
+            )
+            assert properties["$ai_cache_read_input_tokens"] == 10318
+            assert properties.get("$ai_cache_reporting_exclusive") is False
+        finally:
+            set_trace_processors([])
+            processor.shutdown()
+
+    def test_flat_cache_keys_keep_their_own_convention(
+        self, processor, mock_client, mock_span
+    ):
+        """Flat cache keys come from custom models with their own convention, so
+        no inclusive/exclusive flag is declared for them."""
+        mock_span.span_data = GenerationSpanData(
+            model="custom-model",
+            usage={
+                "input_tokens": 100,
+                "output_tokens": 50,
+                "cache_read_input_tokens": 60,
+            },
+        )
+
+        processor.on_span_start(mock_span)
+        processor.on_span_end(mock_span)
+
+        props = mock_client.capture.call_args[1]["properties"]
+        assert props["$ai_cache_read_input_tokens"] == 60
+        assert "$ai_cache_reporting_exclusive" not in props
+
+    def test_caller_cache_reporting_convention_takes_precedence(
+        self, mock_client, mock_span
+    ):
+        """A processor-wide $ai_cache_reporting_exclusive overrides the default
+        declared for nested OpenAI-shaped usage."""
+        processor = PostHogTracingProcessor(
+            client=mock_client,
+            distinct_id="test-user",
+            privacy_mode=False,
+            properties={"$ai_cache_reporting_exclusive": True},
+        )
+        mock_span.span_data = GenerationSpanData(
+            model="gpt-5-mini",
+            usage={
+                "input_tokens": 100,
+                "output_tokens": 50,
+                "input_tokens_details": {"cached_tokens": 60},
+            },
+        )
+
+        processor.on_span_start(mock_span)
+        processor.on_span_end(mock_span)
+
+        props = mock_client.capture.call_args[1]["properties"]
+        assert props["$ai_cache_read_input_tokens"] == 60
+        assert props["$ai_cache_reporting_exclusive"] is True
+
     def test_function_span_mapping(self, processor, mock_client, mock_span):
         """Test FunctionSpanData maps to $ai_span event with type=tool."""
         span_data = FunctionSpanData(

From 2989cd2f36607406c6d607d7033507ca69936711 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:02:10 +0000
Subject: [PATCH 139/245] chore: Release v7.80.3 [skip ci]

---
 .sampo/changesets/openai-agents-cache-reasoning-tokens.md | 5 -----
 openfeature-provider/CHANGELOG.md                         | 6 ++++++
 openfeature-provider/pyproject.toml                       | 2 +-
 posthog/CHANGELOG.md                                      | 6 ++++++
 posthog/version.py                                        | 2 +-
 pyproject.toml                                            | 2 +-
 uv.lock                                                   | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/openai-agents-cache-reasoning-tokens.md

diff --git a/.sampo/changesets/openai-agents-cache-reasoning-tokens.md b/.sampo/changesets/openai-agents-cache-reasoning-tokens.md
deleted file mode 100644
index 342cc3257..000000000
--- a/.sampo/changesets/openai-agents-cache-reasoning-tokens.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Report cached input tokens from OpenAI Agents generation and response spans, which nest them under the usage details fields, and declare them inclusive.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 5c089f077..ee6d3fcd9 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.134 — 2026-10-29
+
+### Patch changes
+
+- Updated dependencies: posthog@7.80.3
+
 ## 0.1.133 — 2026-10-29
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 41b8c489b..a0c4e0a79 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.133"
+version = "0.1.134"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 00de658b6..7a8453a87 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.80.3 — 2026-10-29
+
+### Patch changes
+
+- [4d6e447](https://github.com/posthog/posthog-python/commit/4d6e44766175f80fbbf538ab4369b1f3916f05f7) Report cached input tokens from OpenAI Agents generation and response spans, which nest them under the usage details fields, and declare them inclusive. — Thanks @mosafariuk!
+
 ## 7.80.2 — 2026-10-29
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index e4c192ab3..0fec337ce 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.80.2"
+VERSION = "7.80.3"
diff --git a/pyproject.toml b/pyproject.toml
index 4d11eab27..7ea627f64 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.80.2"
+version = "7.80.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 5d053e840..c4f5ebb93 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2665,7 +2665,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.133"
+version = "0.1.134"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3202,7 +3202,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.80.2"
+version = "7.80.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From c380dc8cc731c4d1474a2427afcd3e426bf68b88 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 14:02:15 +0000
Subject: [PATCH 140/245] Update generated references

---
 .../posthog-python-references-7.80.3.json     | 3548 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3549 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.80.3.json

diff --git a/references/posthog-python-references-7.80.3.json b/references/posthog-python-references-7.80.3.json
new file mode 100644
index 000000000..8ee9a06c2
--- /dev/null
+++ b/references/posthog-python-references-7.80.3.json
@@ -0,0 +1,3548 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.80.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index d8cd45066..8ee9a06c2 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.80.2",
+    "version": "7.80.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 6f765a3cb491de5b414e157e095c8155b59f18e2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:58:37 -0400
Subject: [PATCH 141/245] chore(deps): bump setuptools from 83.0.0 to 84.1.0 in
 /examples/example-ai-autogen in the uv group across 1 directory (#1131)

chore(deps): bump setuptools

Bumps the uv group with 1 update in the /examples/example-ai-llamaindex directory: [setuptools](https://github.com/pypa/setuptools).


Updates `setuptools` from 83.0.0 to 84.1.0
- [Release notes](https://github.com/pypa/setuptools/releases)
- [Changelog](https://github.com/pypa/setuptools/blob/main/NEWS.rst)
- [Commits](https://github.com/pypa/setuptools/compare/v83.0.0...v84.1.0)

---
updated-dependencies:
- dependency-name: setuptools
  dependency-version: 84.1.0
  dependency-type: indirect
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-autogen/uv.lock       |  8 ++++----
 examples/example-ai-crewai/uv.lock        |  6 +++---
 examples/example-ai-dspy/uv.lock          |  6 +++---
 examples/example-ai-litellm/uv.lock       |  6 +++---
 examples/example-ai-llamaindex/uv.lock    | 14 +++++++-------
 examples/example-ai-openai-agents/uv.lock |  6 +++---
 examples/example-ai-pydantic-ai/uv.lock   |  8 ++++----
 examples/example-ai-smolagents/uv.lock    |  8 ++++----
 integration_tests/django5/uv.lock         |  8 ++++----
 9 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/examples/example-ai-autogen/uv.lock b/examples/example-ai-autogen/uv.lock
index b1cbe8a8b..828f4ba21 100644
--- a/examples/example-ai-autogen/uv.lock
+++ b/examples/example-ai-autogen/uv.lock
@@ -100,11 +100,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.76.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index 1998b05a2..32a7cf5d2 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -412,11 +412,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-dspy/uv.lock b/examples/example-ai-dspy/uv.lock
index cbf103c59..c6411e96c 100644
--- a/examples/example-ai-dspy/uv.lock
+++ b/examples/example-ai-dspy/uv.lock
@@ -311,11 +311,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-litellm/uv.lock b/examples/example-ai-litellm/uv.lock
index fc58e156f..00bfa8a21 100644
--- a/examples/example-ai-litellm/uv.lock
+++ b/examples/example-ai-litellm/uv.lock
@@ -271,11 +271,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index af7f08f09..25decdb56 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -293,11 +293,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -1826,7 +1826,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.76.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2373,11 +2373,11 @@ wheels = [
 
 [[package]]
 name = "setuptools"
-version = "83.0.0"
+version = "84.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/eb/7e5f628ee2eb168fecbf8026de7856b2543d6d609cc85f086b9a91ac93d6/setuptools-84.1.0.tar.gz", hash = "sha256:23657205b63d4d31395ab917815247f694aafad28cd21316bf5fd45a51048ea0", size = 1171783, upload-time = "2026-10-19T20:11:43.489Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/18/02/b4bbb90f8f29e334898ff45c6d9b1fffaa6f378017052b3023a06262b5f7/setuptools-84.1.0-py3-none-any.whl", hash = "sha256:5231689c6ac8156cd155cfb98c3fd6fb252c3e7e9bd3d78b64d3c55f132624c9", size = 819380, upload-time = "2026-10-19T20:11:41.684Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-openai-agents/uv.lock b/examples/example-ai-openai-agents/uv.lock
index 87d85b46d..2534f5151 100644
--- a/examples/example-ai-openai-agents/uv.lock
+++ b/examples/example-ai-openai-agents/uv.lock
@@ -58,11 +58,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index 6679c95fd..6e0b9ef75 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -427,11 +427,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -2111,7 +2111,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.76.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
diff --git a/examples/example-ai-smolagents/uv.lock b/examples/example-ai-smolagents/uv.lock
index a35eb7501..fe6653891 100644
--- a/examples/example-ai-smolagents/uv.lock
+++ b/examples/example-ai-smolagents/uv.lock
@@ -43,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -813,7 +813,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.76.0"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
diff --git a/integration_tests/django5/uv.lock b/integration_tests/django5/uv.lock
index 8f39eb073..0eea38c3a 100644
--- a/integration_tests/django5/uv.lock
+++ b/integration_tests/django5/uv.lock
@@ -42,11 +42,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -254,7 +254,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.76.0"
 source = { editable = "../../" }
 dependencies = [
     { name = "backoff" },

From 871ad9e526058b889efd88957f29d0d86ccce5d0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:58:48 -0400
Subject: [PATCH 142/245] chore(deps): bump authlib from 1.7.2 to 1.9.1 (#1140)

Bumps [authlib](https://github.com/authlib/authlib) from 1.7.2 to 1.9.1.
- [Release notes](https://github.com/authlib/authlib/releases)
- [Commits](https://github.com/authlib/authlib/compare/v1.7.2...v1.9.1)

---
updated-dependencies:
- dependency-name: authlib
  dependency-version: 1.9.1
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index c4f5ebb93..167e168e6 100644
--- a/uv.lock
+++ b/uv.lock
@@ -374,15 +374,15 @@ wheels = [
 
 [[package]]
 name = "authlib"
-version = "1.7.2"
+version = "1.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
     { name = "joserfc" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/36/98/7d93f30d029643c0275dbc0bd6d5a6f670661ee6c9a94d93af7ab4887600/authlib-1.7.2.tar.gz", hash = "sha256:2cea25fefcd4e7173bdf1372c0afc265c8034b23a8cd5dcb6a9164b826c64231", size = 176511, upload-time = "2026-05-06T08:10:23.116Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/dc/087c08741a98d234c9b98beef8a28d3c309f814d14b6156422c5815bf6d6/authlib-1.9.1.tar.gz", hash = "sha256:5c7d9848f47cac340f060f76ae0bc09b59f5c8e89cc1bb032d4370a0c55b5974", size = 182700, upload-time = "2026-10-14T14:17:52.307Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/95/adcb68e20c34162e9135f370d6e31737719c2b6f94bc953fe7ed1f10fe21/authlib-1.7.2-py2.py3-none-any.whl", hash = "sha256:3e1faedc9d87e7d56a164eca3ccb6ace0d61b94abe83e92242f8dc8bba9b4a9f", size = 259548, upload-time = "2026-05-06T08:10:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/39/44/a46089266de32a0d809023b6bf31b80a1f26a46954446a7ce695a565cbea/authlib-1.9.1-py2.py3-none-any.whl", hash = "sha256:8b9be8b1e5174dcbf5520e984f1a22dc2edae5b6e40a61d4cedbf86b97e9e69b", size = 266042, upload-time = "2026-10-14T14:17:50.695Z" },
 ]
 
 [[package]]

From c9105c5be181b3e81737c7481dc92f68f0cafcf7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 29 Oct 2026 16:58:57 -0400
Subject: [PATCH 143/245] chore(deps): bump the ai-providers group across 1
 directory with 7 updates (#1145)

Bumps the ai-providers group with 7 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [langchain](https://github.com/langchain-ai/langchain) | `1.4.4` | `1.4.7` |
| [langgraph](https://github.com/langchain-ai/langgraph) | `1.2.14` | `1.2.16` |
| [langchain-core](https://github.com/langchain-ai/langchain) | `1.6.9` | `1.6.13` |
| [langchain-openai](https://github.com/langchain-ai/langchain) | `1.7.0` | `1.7.2` |
| [langchain-anthropic](https://github.com/langchain-ai/langchain) | `1.7.5` | `1.7.6` |
| [google-genai](https://github.com/googleapis/python-genai) | `2.29.0` | `2.32.0` |
| [langchain-protocol](https://github.com/langchain-ai/agent-protocol) | `0.0.19` | `0.0.20` |



Updates `langchain` from 1.4.4 to 1.4.7
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain==1.4.4...langchain==1.4.7)

Updates `langgraph` from 1.2.14 to 1.2.16
- [Release notes](https://github.com/langchain-ai/langgraph/releases)
- [Commits](https://github.com/langchain-ai/langgraph/compare/1.2.14...1.2.16)

Updates `langchain-core` from 1.6.9 to 1.6.13
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-core==1.6.9...langchain-core==1.6.13)

Updates `langchain-openai` from 1.7.0 to 1.7.2
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-openai==1.7.0...langchain-openai==1.7.2)

Updates `langchain-anthropic` from 1.7.5 to 1.7.6
- [Release notes](https://github.com/langchain-ai/langchain/releases)
- [Commits](https://github.com/langchain-ai/langchain/compare/langchain-anthropic==1.7.5...langchain-anthropic==1.7.6)

Updates `google-genai` from 2.29.0 to 2.32.0
- [Release notes](https://github.com/googleapis/python-genai/releases)
- [Changelog](https://github.com/googleapis/python-genai/blob/main/CHANGELOG.md)
- [Commits](https://github.com/googleapis/python-genai/compare/v2.29.0...v2.32.0)

Updates `langchain-protocol` from 0.0.19 to 0.0.20
- [Release notes](https://github.com/langchain-ai/agent-protocol/releases)
- [Commits](https://github.com/langchain-ai/agent-protocol/compare/langchain-protocol==0.0.19...langchain-protocol==0.0.20)

---
updated-dependencies:
- dependency-name: langchain
  dependency-version: 1.4.7
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langgraph
  dependency-version: 1.2.16
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-core
  dependency-version: 1.6.13
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-openai
  dependency-version: 1.7.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: langchain-anthropic
  dependency-version: 1.7.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: ai-providers
- dependency-name: google-genai
  dependency-version: 2.32.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: ai-providers
- dependency-name: langchain-protocol
  dependency-version: 0.0.20
  dependency-type: indirect
  update-type: version-update:semver-patch
  dependency-group: ai-providers
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 60 ++++++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/uv.lock b/uv.lock
index 167e168e6..e94d48c26 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1297,7 +1297,7 @@ requests = [
 
 [[package]]
 name = "google-genai"
-version = "2.29.0"
+version = "2.32.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1311,9 +1311,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/21/2b/977616ef350e51d3d263eb43be23a91be793544cd937b51c0fac313be233/google_genai-2.29.0.tar.gz", hash = "sha256:124d3eef9ff6b9e4ea548f95ff5b7721683e7990c0a936b006d9e2ab61ea897d", size = 706902, upload-time = "2026-10-07T22:22:57.153Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f9/89c95879bd58f176f82415c1a63a9dce528ea2b7a83a155412db5b1c783b/google_genai-2.32.0.tar.gz", hash = "sha256:9e8fb72f0a878291bc20b941d5d535e249f5729290565b7d49406827a0c30152", size = 750015, upload-time = "2026-10-21T00:38:45.526Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/27/a3dede4a1deb21f7fde6a171daa039bf0ea149a5e7826a785e8f109a6e13/google_genai-2.29.0-py3-none-any.whl", hash = "sha256:7adda55cb6746fb46d38ad3202c3372840b96eede964b5fb3df1469cd4998570", size = 1167603, upload-time = "2026-10-07T22:22:55.215Z" },
+    { url = "https://files.pythonhosted.org/packages/97/70/964baf520f36019ad4e4ce316e6dc943189f3b398654ff8277dadb764f6d/google_genai-2.32.0-py3-none-any.whl", hash = "sha256:cf71a629df18510cd837cacb4843b38a2db6834c69eb93963a0d8ee4d657b725", size = 1213907, upload-time = "2026-10-21T00:38:43.471Z" },
 ]
 
 [[package]]
@@ -1806,30 +1806,30 @@ wheels = [
 
 [[package]]
 name = "langchain"
-version = "1.4.4"
+version = "1.4.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "langgraph" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6a/a4/a3ceefc3ec734912ca3a21dd79a5e4a98af73015a87e64d284a92cd5572c/langchain-1.4.4.tar.gz", hash = "sha256:baac6e13c08460e1decd0e60061b9a87c07135f1c977424040b0b57ff7bc7887", size = 742902, upload-time = "2026-10-08T22:14:10.86Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d1/6b/7147b4cfa86091e05e3c0189952d976e13ef27249c8cd9e46d8c742a5b5c/langchain-1.4.7.tar.gz", hash = "sha256:818275348cd707f7fbbe92ece0a725c25823140a054cf29865f420e0200fa2af", size = 762840, upload-time = "2026-10-21T21:39:01.141Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/36/c348f812eb37a137de2c80140ed1324ab11b75fa5a845e3f1035bacaac4a/langchain-1.4.4-py3-none-any.whl", hash = "sha256:2fd27e9a2d54ebcd915ac5ea51d79c772e020567ef6c6a76678182055489b804", size = 165363, upload-time = "2026-10-08T22:14:09.321Z" },
+    { url = "https://files.pythonhosted.org/packages/93/2e/86a102e61fc88ede073aebdb795fef0eb058a887bed4aa862e8ca2697565/langchain-1.4.7-py3-none-any.whl", hash = "sha256:bc40d4a9a46f0c3d75e316c0e576931fe19bceef83912a71dc1e0df781eb8f82", size = 170549, upload-time = "2026-10-21T21:38:59.466Z" },
 ]
 
 [[package]]
 name = "langchain-anthropic"
-version = "1.7.5"
+version = "1.7.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anthropic" },
     { name = "langchain-core" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/91/e6/45ead93ef6d9f244b502a6a32bf9a185b3da1cc7fa8003896a102dadac09/langchain_anthropic-1.7.5.tar.gz", hash = "sha256:6016f38e5c4bf12c16ecfa76abf133a978f459f4d2887b8e28435ae1ff00beb3", size = 764625, upload-time = "2026-09-29T15:22:07.106Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3c/45/b369666909be4a6f58877b18e692655ee792e06047c6c572d1218e09a31c/langchain_anthropic-1.7.6.tar.gz", hash = "sha256:e5b41959a39810e69bc608fd6622b7d5d017bde93f858b09332fbb6ac764c393", size = 765188, upload-time = "2026-10-12T14:39:58.537Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/a8/c507f2c1859b584843983e98bc71e0066c16a77e6c181921c928e0fdbcf7/langchain_anthropic-1.7.5-py3-none-any.whl", hash = "sha256:b21ef0e0c2d6175235a5b7eef4f5f89057df92d42dbfab66920a05605ef7173a", size = 65239, upload-time = "2026-09-29T15:22:05.832Z" },
+    { url = "https://files.pythonhosted.org/packages/97/d6/da1ba42b7c26cd511c9be5473dbb178c51b07a337e94f09188d45f0306a2/langchain_anthropic-1.7.6-py3-none-any.whl", hash = "sha256:06bee97006d99e9a04abc4bd56599fc356c0c7f7f2a97629645cb603d9785c73", size = 65535, upload-time = "2026-10-12T14:39:57.386Z" },
 ]
 
 [[package]]
@@ -1876,7 +1876,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.6.9"
+version = "1.6.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1890,14 +1890,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/d3/e9611e44e62ab8175127e137587c62dc2ed00e2615aebd89dfdb77f5fba0/langchain_core-1.6.9.tar.gz", hash = "sha256:34394228603e6f0bd24ce4e773b58b7d160e1b8cf489ecb350cf41f5366f5e92", size = 1010051, upload-time = "2026-10-08T20:11:19.881Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/76/0b8e5383a9c6a05bde284790d661487bb586cf101f43e8d4dac1fb3da1ee/langchain_core-1.6.13.tar.gz", hash = "sha256:756d8fd971cd7e3a5a19cf5453a81159351bd40cbfe62cbfe7e2ee3941008772", size = 1018477, upload-time = "2026-10-21T20:43:32.248Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/41/fdcdd869c052874b17e2325c986cf8c2fc6bbefa3b9d5404dd64dfffb12a/langchain_core-1.6.9-py3-none-any.whl", hash = "sha256:2bacea12270fd4cfdeeefdc5977e7e8b3c30814c509534d1ef43f4e5b7d3f657", size = 572951, upload-time = "2026-10-08T20:11:18.189Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/2f/c15b026e7b4aa093bc237c909bf909e8a59143b1315efee43c296fad58ce/langchain_core-1.6.13-py3-none-any.whl", hash = "sha256:8605de6f84a49902ef6be03d6fe2a126e7dfc35184315989689f341181f0a8fb", size = 574683, upload-time = "2026-10-21T20:43:30.951Z" },
 ]
 
 [[package]]
 name = "langchain-openai"
-version = "1.7.0"
+version = "1.7.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -1905,21 +1905,21 @@ dependencies = [
     { name = "openai" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/68/dd7f7ef76efe58222d37f1b1a5595b1bb368fc9165f71526db26e4c5759e/langchain_openai-1.7.0.tar.gz", hash = "sha256:7df2db16d32320ba563b7e4291a71ec6bf7b0ea8a5369ed2a0501d74928ea6d0", size = 3404806, upload-time = "2026-10-08T16:07:35.135Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/ca/b64799a9f2ee688aa6c238f5230b20d150b19cc5892bdcb6faf2b59866f1/langchain_openai-1.7.2.tar.gz", hash = "sha256:e1fcbc7a96f7c8c94679d61639a979bba88f27889c0a68dfa225b8057345328d", size = 3405949, upload-time = "2026-10-14T13:50:59.956Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/ef/3f40387231281eaefb0bec31bfa86a7d533de9d90b46802c3e24d436a163/langchain_openai-1.7.0-py3-none-any.whl", hash = "sha256:a4d319385019c010c579b39e8951e4d5ededeacf94cd9c79162f4cb7ecba50fb", size = 145622, upload-time = "2026-10-08T16:07:33.119Z" },
+    { url = "https://files.pythonhosted.org/packages/39/5d/8c4888a21087e4cd1c32965613a1a17cfc8e90e41ba5205c3dad302f3410/langchain_openai-1.7.2-py3-none-any.whl", hash = "sha256:9be7980edf355ca2dd595b795a5125836ccf04515ef9377228913246156e59f5", size = 146367, upload-time = "2026-10-14T13:50:58.697Z" },
 ]
 
 [[package]]
 name = "langchain-protocol"
-version = "0.0.19"
+version = "0.0.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/14/56/913599f2f9cec8524868929f12d72b2ede377a6056ca8a40a32bdadfa535/langchain_protocol-0.0.19.tar.gz", hash = "sha256:79d90a1425122ac87e8052e2ec054fbd09c3edbf341bdfb6397112a495c7bf8c", size = 6265, upload-time = "2026-08-26T21:12:00.703Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cb/8b/d908d082c3cf5368ddd1816ed114de79c873f979ba7f98b95fab0e841643/langchain_protocol-0.0.20.tar.gz", hash = "sha256:0f5bd002474265648e91161771a9e0438fe9480bd55a416e51af0f60070637ec", size = 6280, upload-time = "2026-10-20T11:13:50.84Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/80/c9/f6cbf357d48ccbd18bb394433b1fd7ad9be004eed9377ad08bb85777e5e6/langchain_protocol-0.0.19-py3-none-any.whl", hash = "sha256:4cdf879a492a35980fd859ae792d3c65458ccaae504e183c9a10d7eac1f0720f", size = 7327, upload-time = "2026-08-26T21:11:59.781Z" },
+    { url = "https://files.pythonhosted.org/packages/02/4b/f1c99a0b27c5ff8b4b131c0d6e62012c17cc424089efe213767db927afd2/langchain_protocol-0.0.20-py3-none-any.whl", hash = "sha256:3c935e5e46b0f6f9cb52f45ba7cfa53d1b9fa80c82c4a277d47f03e07f7385b1", size = 7347, upload-time = "2026-10-20T11:13:49.566Z" },
 ]
 
 [[package]]
@@ -1936,7 +1936,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.14"
+version = "1.2.16"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
@@ -1946,22 +1946,22 @@ dependencies = [
     { name = "pydantic" },
     { name = "xxhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/49/3f/6e60789eab2c5ceaf34ba2c626ac345df93b026bbe7385018aa4b9c30397/langgraph-1.2.14.tar.gz", hash = "sha256:5b1a72b7a7f994ac6947b7751fbbe00e949f8bb44d9ab78881604b703247ae55", size = 752793, upload-time = "2026-10-06T14:41:19.789Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/db/65/69de99a24546c1e3b75a67905dbcc17ed6cd0ed81694d4cc021ed688a60d/langgraph-1.2.16.tar.gz", hash = "sha256:e4dd63480bfd3ee14a6ab80ecf1311698780519693d8e3b67a28f3486e69e1f7", size = 772613, upload-time = "2026-10-16T22:11:14.147Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/4a/f976df0d3cf7fb7986dc39f656c6b7b5655834430e9bdfaef1e1e4fffaba/langgraph-1.2.14-py3-none-any.whl", hash = "sha256:e3f5f8ff4259f9281b73ff50fc9ef5cc3b025b8936b8283ecdca7cc0c4128690", size = 255980, upload-time = "2026-10-06T14:41:18.129Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/eb/ceb9bed99f6549e9ec51c497b749062d19e0a1c68fea0ad801d55c4a9691/langgraph-1.2.16-py3-none-any.whl", hash = "sha256:aeceb1bc49488409f12b02f1e51881099391d9e85bcfd78e1dbead71831c41b5", size = 260357, upload-time = "2026-10-16T22:11:12.638Z" },
 ]
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.1.1"
+version = "4.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "ormsgpack" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/83/47/886af6f886f0bff2273164a45f008694e48a96ff3cd25ff0228f2aa9480e/langgraph_checkpoint-4.1.1.tar.gz", hash = "sha256:6c2bdb530c91f91d7d9c1bd100925d0fc4f498d418c17f3587d1526279482a25", size = 184020, upload-time = "2026-05-22T16:57:38.503Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/69/31fdbdc65a85bbd6178afa193c772bb926620f47b4869638bc2bc80afaaa/langgraph_checkpoint-4.3.0.tar.gz", hash = "sha256:c75965d84cc2c1d549163e910a15bcb577758001b141619d05297c463280b018", size = 182652, upload-time = "2026-10-12T22:26:31.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/b4/71425e3e38be92611300b9cc5e46a5bf98ab23f5ea8a75b73d02a2f1413c/langgraph_checkpoint-4.1.1-py3-none-any.whl", hash = "sha256:25d29144b082827218e7bc3f1e9b0566a4bb007895cd6cc26f66a8428739f56e", size = 56212, upload-time = "2026-05-22T16:57:37.203Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/0c/84747e340bf4f29291c84cdd5733fc8d0a822f3d33bb24e664a18afa4a7c/langgraph_checkpoint-4.3.0-py3-none-any.whl", hash = "sha256:bedfafe2f997ded60e4fa593e79f56f436a6e45586392dc382aa810d0c751c64", size = 58063, upload-time = "2026-10-12T22:26:30.429Z" },
 ]
 
 [[package]]
@@ -1995,23 +1995,27 @@ wheels = [
 
 [[package]]
 name = "langsmith"
-version = "0.8.18"
+version = "0.14.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "httpx" },
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx2" },
     { name = "orjson", marker = "platform_python_implementation != 'PyPy'" },
     { name = "packaging" },
     { name = "pydantic" },
     { name = "requests" },
     { name = "requests-toolbelt" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
     { name = "uuid-utils" },
     { name = "websockets" },
     { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/d9/a6681aa9847bbbc5ec21abe20a5e233b94e5edcfe39624db607ac7e8ccb4/langsmith-0.8.18.tar.gz", hash = "sha256:32dde9c0e67e053e0fb738921fc8ced768af7b8fa83d7a0e3fd63597cf8776dd", size = 4526988, upload-time = "2026-06-19T13:12:17.123Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/f7/07a02241b6e6ed3df4e31a64ed09cb522c47227816da3d71097e7cf94657/langsmith-0.14.12.tar.gz", hash = "sha256:b4d6a24ed74333095da476803ad9d22ee35f9dae1052cebf1e366d3889a9b675", size = 5038994, upload-time = "2026-10-21T20:16:22.565Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/70/0e0cc80a3b064c8d6c8d697c3125ed86e39d5a7393ec6dc8b07cb1cf13c4/langsmith-0.8.18-py3-none-any.whl", hash = "sha256:3940183349993faef48e6c7d08e4822ee9cefd906b362d0e3c2d650314d2f282", size = 508108, upload-time = "2026-06-19T13:12:15.348Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/6c/33e2de8d8d809895263e4f24ef7619e5535e3ece7de863ffbe49c1b7a60d/langsmith-0.14.12-py3-none-any.whl", hash = "sha256:9dafba7f615afa77204dc8afbb9c803e4ba1b55e96249f12c8f9aafb23fae6d0", size = 883644, upload-time = "2026-10-21T20:16:20.039Z" },
 ]
 
 [[package]]

From 50cf3573f2af46455c1a313e1649649f9d671180 Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Fri, 30 Oct 2026 09:47:26 +0100
Subject: [PATCH 144/245] ci: pin Python 3.11 by minor version for Ubuntu 26.04
 runners (#1153)

---
 .github/actions/setup-python-dev/action.yml | 2 +-
 .github/workflows/ci.yml                    | 6 +++---
 .github/workflows/release.yml               | 6 +++---
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/actions/setup-python-dev/action.yml b/.github/actions/setup-python-dev/action.yml
index 347ebeafd..5739fa55d 100644
--- a/.github/actions/setup-python-dev/action.yml
+++ b/.github/actions/setup-python-dev/action.yml
@@ -5,7 +5,7 @@ inputs:
     python-version:
         description: Python version to install.
         required: false
-        default: 3.11.11
+        default: 3.11
 
 runs:
     using: composite
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 92334514d..0a605fc14 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -89,7 +89,7 @@ jobs:
             - name: Set up Python 3.11
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
               with:
-                  python-version: 3.11.11
+                  python-version: 3.11
 
             - name: Check strict downstream Pyright usage
               run: .github/scripts/check_strict_types.sh
@@ -106,7 +106,7 @@ jobs:
             - name: Set up Python 3.11
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
               with:
-                  python-version: 3.11.11
+                  python-version: 3.11
 
             - name: Install uv
               uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
@@ -238,7 +238,7 @@ jobs:
               if: steps.changes.outputs.changed == 'true'
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
               with:
-                  python-version: 3.11.11
+                  python-version: 3.11
 
             - name: Install uv
               if: steps.changes.outputs.changed == 'true'
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index e8afa85bc..0dd57cb0a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -98,7 +98,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
-          python-version: 3.11.11
+          python-version: 3.11
 
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
@@ -303,7 +303,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
-          python-version: 3.11.11
+          python-version: 3.11
 
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
@@ -470,7 +470,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
-          python-version: 3.11.11
+          python-version: 3.11
 
       - name: Install uv
         uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0

From 01e91db94185969f636d501a58a21eb9f2c3721e Mon Sep 17 00:00:00 2001
From: Harley Alexander <43975092+mayteio@users.noreply.github.com>
Date: Fri, 30 Oct 2026 10:05:42 +0000
Subject: [PATCH 145/245] feat: send transactional email from posthog templates
 (#1093)

* feat: send transactional email from posthog templates

Add posthog.emails.send() on Client and AsyncClient, plus standalone Emails and AsyncEmails in posthog.emails for processes that only send email. Sends go to the app host with a project secret API key and an Idempotency-Key, and retry network errors, rate limits, an in-flight key and 503 with the same key. Errors raise EmailError with PostHog's code and a Resend-style name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: c62b30cd-eb2e-496c-a73d-2a6e7a52a62e

* fix: keep the email secret key off custom hosts and close email transports

client.emails only infers PostHog Cloud app hosts. A custom host raises app_host_required before any request, so an ingestion proxy never receives the project secret key. A kept emails reference now reads the client's disabled state on every send. Shutdown closes the email transport, a forked child drops the parent's email session, and the retry ceiling applies after jitter. Docs examples use client.emails.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: c62b30cd-eb2e-496c-a73d-2a6e7a52a62e

* fix: refuse email sends after shutdown and drain async sends first

client.emails now asks the parent client to admit each send. After shutdown, a kept or new client.emails raises EmailError with code client_closed and makes no request. On AsyncClient, an admitted send is an in-flight operation, so shutdown waits for it, retries included, before it closes the email transport.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: c62b30cd-eb2e-496c-a73d-2a6e7a52a62e

* feat: configure email sends on the client and document setup

Posthog and AsyncPosthog take app_host, email_request_timeout_seconds and email_request_max_retries, so client.emails works behind a custom host and a job runner can turn retries off. Emails takes a session and AsyncEmails an http_client, which gives tests a supported no-network path. The posthog.emails module docs now hold a setup quickstart: keys and scope, template ID, hosts, retries, errors to expect, cleanup and testing. The release note names client.emails.send().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: c62b30cd-eb2e-496c-a73d-2a6e7a52a62e

* fix: match the email contract's missing_app_host and keep network causes

- A non-Cloud host without app_host now fails with missing_app_host, the code the cross-SDK contract in PostHog/posthog#120921 defines, matching posthog-node.
- A network_error keeps the requests or httpx exception as __cause__, so a failed send is easier to debug.
- Regenerate the public API snapshot after the rebase onto main.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* fix: keep the bearer token and send timeout on injected async clients

An httpx.AsyncClient passed as http_client can carry its own auth and timeout. Its auth replaced the email's Bearer header, and its timeout replaced the send timeout, so a client built with timeout=None left sends unbounded. Each async send now passes auth=None and timeout=self.timeout.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* fix: name 422 send checks validation_error

The template send route answers 422 for recipient_suppressed, sending_paused and sending_suspended as well as idempotency_key_reused. Only idempotency_key_reused is now invalid_idempotent_request; the send checks are validation_error, as the cross-SDK contract names them and posthog-node does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* fix: raise client_disabled for email sends from a disabled client

A disabled client returned SendEmailResult(id=None), so a caller that treats a returned result as sent dropped the email silently. It now sends nothing and raises EmailError with code client_disabled (name application_error), as the cross-SDK contract in PostHog/posthog#120921 defines and posthog-node does. SendEmailResult.id is always the queued message ID, so its type is str.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* feat: send transactional email through the single send endpoint

`emails.send()` now posts to `/api/projects/@current/messaging/send/email/` with the template ID in the body as `template.id`, instead of the template-scoped route.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* feat: read a transactional email's status with emails.get

`emails.get(message_id)` on `Emails` and `AsyncEmails` reads `/api/projects/@current/messaging/emails/{id}/` and returns an `EmailStatus` with `status`, `created_at`, `status_at` and `reason`. It retries network errors, rate limits and an unavailable service like `send`, which now shares that attempt loop.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* docs: describe the email error name as a category

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be

* feat: add a per-send max_retries to emails.send

`send(max_retries=...)` on `Emails` and `AsyncEmails` overrides the client's retry limit for one send, like posthog-node's `maxRetries`. A negative or non-integer value raises `ValueError` before any request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be
---
 .sampo/changesets/transactional-emails.md |   5 +
 posthog/async_client.py                   |  60 +-
 posthog/client.py                         |  62 ++
 posthog/emails.py                         | 942 ++++++++++++++++++++++
 posthog/request.py                        |  13 +
 posthog/test/test_emails.py               | 574 +++++++++++++
 references/public_api_snapshot.txt        |  49 +-
 typings/requests/__init__.pyi             |   2 +
 8 files changed, 1704 insertions(+), 3 deletions(-)
 create mode 100644 .sampo/changesets/transactional-emails.md
 create mode 100644 posthog/emails.py
 create mode 100644 posthog/test/test_emails.py

diff --git a/.sampo/changesets/transactional-emails.md b/.sampo/changesets/transactional-emails.md
new file mode 100644
index 000000000..21c9e6c76
--- /dev/null
+++ b/.sampo/changesets/transactional-emails.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Send transactional email from PostHog email templates with `client.emails.send()` on `Posthog` and `AsyncPosthog`, or with `Emails` and `AsyncEmails` from `posthog.emails` in a process that only sends email. A send needs a project secret API key, goes to the app host, sends an idempotency key, and retries network errors, rate limits and an unavailable service with the same key. Set `app_host`, `email_request_timeout_seconds` and `email_request_max_retries` on the client to configure sends, or `max_retries` on one send. Errors raise `EmailError` with PostHog's error `code` and a category `name`. Read what happened to a sent email with `client.emails.get(message_id)`, which returns an `EmailStatus` with `status`, `created_at`, `status_at` and `reason` for 30 days after the send.
diff --git a/posthog/async_client.py b/posthog/async_client.py
index d1015ebba..57ed13e29 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -10,7 +10,7 @@
 import warnings
 import weakref
 from datetime import datetime, timezone
-from typing import Any, Dict, Mapping, Optional, Union
+from typing import Any, Callable, Dict, Mapping, Optional, Union
 from uuid import UUID, uuid4
 
 from typing_extensions import Unpack
@@ -70,6 +70,7 @@
     try_attach_code_variables_to_frames,
 )
 from .consumer import MAX_MSG_SIZE
+from .emails import AsyncEmails, _client_emails, _validate_options
 from .feature_flag_evaluations import (
     FeatureFlagEvaluations,
     _EvaluatedFlagRecord,
@@ -129,6 +130,9 @@ def __init__(
         personal_api_key: Optional[str] = None,
         feature_flags_request_timeout_seconds: float = 3,
         feature_flags_request_max_retries: int = 1,
+        app_host: Optional[str] = None,
+        email_request_timeout_seconds: float = 15,
+        email_request_max_retries: int = 2,
     ) -> None:
         if flush_at <= 0:
             raise ValueError("flush_at must be greater than zero")
@@ -173,6 +177,10 @@ def __init__(
             else resolved_secret_key
         ) or None
         self.personal_api_key = self.secret_key
+        _validate_options(email_request_timeout_seconds, email_request_max_retries)
+        self.app_host = app_host
+        self.email_request_timeout_seconds = email_request_timeout_seconds
+        self.email_request_max_retries = email_request_max_retries
         self.feature_flags_request_timeout_seconds = (
             feature_flags_request_timeout_seconds
         )
@@ -247,6 +255,49 @@ def __init__(
         self._duplicate_client_registry_key: Optional[tuple[str, str]] = None
         self._register_duplicate_client()
 
+    _emails: Optional[AsyncEmails] = None
+
+    @property
+    def emails(self) -> AsyncEmails:
+        """
+        Send transactional email from PostHog email templates, and read the
+        status of each email sent with ``get``.
+
+        Needs ``secret_key``, a project secret API key with the ``hog_flow:write``
+        scope, and ``posthog[async]``. Sends go to ``app_host``, or to the PostHog
+        Cloud app host of ``host``. ``email_request_timeout_seconds`` and
+        ``email_request_max_retries`` configure each send. A disabled or shut-down
+        client sends nothing. See ``posthog.emails`` for setup.
+
+        Examples:
+            ```python
+            await client.emails.send(
+                to="user@example.com",
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                distinct_id="user_123",
+            )
+            ```
+        """
+        if self._emails is None:
+            self._emails = _client_emails(
+                AsyncEmails,
+                self.secret_key,
+                self.host,
+                lambda: self.disabled,
+                self._admit_email_send,
+                app_host=self.app_host,
+                timeout=self.email_request_timeout_seconds,
+                max_retries=self.email_request_max_retries,
+            )
+        return self._emails
+
+    def _admit_email_send(self) -> Optional[Callable[[], None]]:
+        # Shutdown waits for in-flight operations before it closes the email transport.
+        if not self._accepting or self._closed:
+            return None
+        completion = self._start_inflight_operation()
+        return lambda: self._finish_inflight_operation(completion)
+
     async def __aenter__(self) -> AsyncClient:
         self._ensure_workers_started()
         return self
@@ -1219,6 +1270,13 @@ async def shutdown(self) -> None:
                 self.log.exception("Failed to close async capture transport")
                 errors.append(error)
 
+            if self._emails is not None:
+                try:
+                    await self._emails.aclose()
+                except Exception as error:
+                    self.log.exception("Failed to close the async email transport")
+                    errors.append(error)
+
             try:
                 self._unregister_duplicate_client()
             except Exception as error:
diff --git a/posthog/client.py b/posthog/client.py
index 3b918b0ba..388e20b2d 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -58,6 +58,7 @@
     set_context_session as _context_set_context_session,
     tag as _context_tag,
 )
+from posthog.emails import Emails, _client_emails, _no_op, _validate_options
 from posthog.exception_capture import ExceptionCapture
 from posthog._logging import _configure_posthog_logging
 from posthog.exception_utils import (
@@ -729,6 +730,9 @@ def __init__(
         _use_ai_lane=False,
         _enable_multimodal_capture=False,
         traces: Optional[dict] = None,
+        app_host: Optional[str] = None,
+        email_request_timeout_seconds: float = 15,
+        email_request_max_retries: int = 2,
     ):
         """
         Initialize a new PostHog client instance.
@@ -780,6 +784,15 @@ def __init__(
             feature_flags_request_max_retries: Number of retries for feature flag
                 requests after network, transport, or timeout failures. Defaults
                 to 1. Set to 0 to disable retries.
+            app_host: Your PostHog app host, such as ``https://posthog.example.com``.
+                ``emails`` sends there. Needed only when ``host`` is not PostHog
+                Cloud, for example a reverse proxy, which must not receive the
+                secret key.
+            email_request_timeout_seconds: Timeout in seconds for each email send
+                request. Defaults to 15.
+            email_request_max_retries: Number of retries for an email send after a
+                network error, a rate limit, or an unavailable service. Defaults to 2.
+                Set to 0 when a job runner already retries the send.
             super_properties: Properties merged into every captured event.
             enable_exception_autocapture: Automatically capture uncaught
                 exceptions.
@@ -1055,6 +1068,10 @@ def __init__(
             else resolved_secret_key
         ) or None
         self.personal_api_key = self.secret_key
+        _validate_options(email_request_timeout_seconds, email_request_max_retries)
+        self.app_host = app_host
+        self.email_request_timeout_seconds = email_request_timeout_seconds
+        self.email_request_max_retries = email_request_max_retries
         if debug:
             # Ensures that debug level messages are logged when debug mode is on.
             # Otherwise, defaults to WARNING level. See https://docs.python.org/3/howto/logging.html#what-happens-if-no-configuration-is-provided
@@ -1228,6 +1245,43 @@ def _set_library_identity(self, library_id: str, library_version: str) -> None:
     def _request_identity_kwargs(self) -> Dict[str, str]:
         return {"_user_agent": self._sdk_info} if self._sdk_info != _USER_AGENT else {}
 
+    _emails: Optional[Emails] = None
+
+    @property
+    def emails(self) -> Emails:
+        """
+        Send transactional email from PostHog email templates, and read the
+        status of each email sent with ``get``.
+
+        Needs ``secret_key``, a project secret API key with the ``hog_flow:write``
+        scope. Sends go to ``app_host``, or to the PostHog Cloud app host of
+        ``host``. ``email_request_timeout_seconds`` and ``email_request_max_retries``
+        configure each send. A disabled or shut-down client sends nothing. See
+        ``posthog.emails`` for setup.
+
+        Examples:
+            ```python
+            client.emails.send(
+                to="user@example.com",
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                template_data={"name": "Ada"},
+                distinct_id="user_123",
+            )
+            ```
+        """
+        if self._emails is None:
+            self._emails = _client_emails(
+                Emails,
+                self.secret_key,
+                self.host,
+                lambda: self.disabled,
+                lambda: None if self._shutdown_requested else _no_op,
+                app_host=self.app_host,
+                timeout=self.email_request_timeout_seconds,
+                max_retries=self.email_request_max_retries,
+            )
+        return self._emails
+
     @property
     def queue(self) -> Queue:
         """The analytics lane's queue (kept for backwards compatibility)."""
@@ -2417,6 +2471,8 @@ def _reinit_after_fork(self):
         self._lifecycle_lock = threading.Lock()
         self._lifecycle_condition = threading.Condition(self._lifecycle_lock)
         self._lifecycle_owner = None
+        # The parent's email session and its lock are not safe to share with the child.
+        self._emails = None
         self._deferred_lifecycle_thread_pending = False
         self._deferred_lifecycle_dirty = False
         self._lifecycle_callback_context = ContextVar(
@@ -3093,6 +3149,12 @@ def _join_once(
                 self._shutdown_flag_definition_cache_provider,
                 errors,
             )
+            if self._emails is not None:
+                self._run_lifecycle_cleanup(
+                    "Failed to close the email transport during lifecycle cleanup",
+                    self._emails.close,
+                    errors,
+                )
             self._run_lifecycle_cleanup(
                 "Failed to unregister client during lifecycle cleanup",
                 self._unregister_duplicate_client,
diff --git a/posthog/emails.py b/posthog/emails.py
new file mode 100644
index 000000000..72b1ca3ef
--- /dev/null
+++ b/posthog/emails.py
@@ -0,0 +1,942 @@
+"""Transactional email, sent from an email template in PostHog.
+
+Setup:
+
+1. In PostHog, open the email template under Workflows, make it transactional,
+   and copy its ID. ``template_id`` is that UUID.
+2. Create a project secret API key (``phs_...``) with Workflow write access
+   (``hog_flow:write``) in your project settings. The project API key
+   (``phc_...``) captures events but cannot send email.
+3. Send from the client you already use, or from :class:`Emails` in a process
+   that only sends email:
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("phc_...", secret_key="phs_...", host="https://eu.i.posthog.com")
+result = posthog.emails.send(
+    to="user@example.com",
+    template_id="<template UUID>",
+    template_data={"name": "Ada"},  # fills {{ variables.name }}
+    distinct_id="user_123",
+    idempotency_key="welcome:user_123",
+)
+print(result.id)  # the queued email
+```
+
+``posthog.emails`` above is the client's property. For async code, use
+``AsyncPosthog`` or :class:`AsyncEmails` with ``posthog[async]`` installed.
+
+Where sends go: a client on PostHog Cloud sends to its region's app host,
+``us.posthog.com`` or ``eu.posthog.com``. For any other ``host``, such as a
+reverse proxy, set ``app_host`` on the client, because the proxy must not
+receive the secret key. :class:`Emails` takes the app host as ``host``.
+
+What a result means: PostHog queued the email. Delivery happens later, and the
+template's workflow in PostHog shows its sends, deliveries and failures.
+
+Timeouts and retries: each request times out after 15 seconds. A send retries
+network errors, rate limits and an unavailable service twice, waiting about 1
+and then 2 seconds, or the server's ``Retry-After`` if that is longer. A
+``Retry-After`` over 30 seconds raises at once. Every attempt sends the same
+idempotency key, so a retry never sends twice. Set
+``email_request_max_retries=0`` on the client, or ``max_retries=0`` on
+:class:`Emails`, when a job runner already retries the send, and pass an
+``idempotency_key`` that names the email, such as ``welcome:user_123``.
+
+Errors: a send that is not queued raises :class:`EmailError`. Branch on
+``code``. The ones a setup usually hits:
+
+- ``missing_secret_key``: the client has no ``secret_key``.
+- ``missing_app_host``: the client's ``host`` is not PostHog Cloud. Set ``app_host``.
+- ``authentication_failed`` (401) or ``permission_denied`` (403): the key is
+  wrong, or it lacks ``hog_flow:write``.
+- ``not_found`` (404): the template ID is wrong, or transactional email is not
+  enabled for the project.
+- ``client_disabled``: the client is disabled, so it sends nothing.
+- ``client_closed``: the client is shut down.
+
+Status: ``emails.get(message_id)`` reads what happened to a sent email, for
+30 days after the send, as an :class:`EmailStatus`. A key with only
+``hog_flow:read`` can read statuses but not send. ``get`` raises ``not_found``
+(404) for an unknown ID, an email older than 30 days, or for a few seconds
+after the send.
+
+Cleanup: ``shutdown()`` on the client closes its email connections. Close a
+standalone :class:`Emails` with ``close()`` or a ``with`` block.
+
+Testing without network calls: pass your own transport, ``session`` to
+:class:`Emails` or ``http_client`` to :class:`AsyncEmails`, with a fake adapter
+or ``httpx.MockTransport``. Any library that mocks ``requests`` or ``httpx``
+works too. A disabled client sends nothing and raises ``client_disabled``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import importlib
+import json
+import logging
+import math
+import random
+import re
+import threading
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from types import TracebackType
+from typing import Any, Callable, Mapping, Optional, TypeVar, Union
+from uuid import UUID, uuid4
+
+import requests
+
+from .capture_v1 import _parse_retry_after
+from .request import (
+    EU_APP_ENDPOINT,
+    US_APP_ENDPOINT,
+    DatetimeSerializer,
+    determine_app_host,
+)
+from .utils import clean
+from .version import VERSION
+
+__all__ = [
+    "AsyncEmails",
+    "EmailError",
+    "EmailStatus",
+    "EmailWarning",
+    "Emails",
+    "SendEmailResult",
+]
+
+log = logging.getLogger("posthog")
+
+_SEND_PATH = "/api/projects/@current/messaging/send/email/"
+_STATUS_PATH = "/api/projects/@current/messaging/emails/{message_id}/"
+_MAX_RETRY_DELAY = 30.0
+_IDEMPOTENCY_KEY = re.compile(r"^[\x21-\x7e]{1,255}$")
+_IN_FLIGHT_CODES = frozenset({"idempotency_key_in_flight"})
+_QUOTA_CODES = frozenset({"quota_limited"})
+
+
+class EmailError(Exception):
+    """PostHog did not queue the email, or the client could not tell whether it did.
+
+    Branch on ``code``, PostHog's stable error code, or on ``name``, a coarse
+    category of the failure. The message never contains the secret key or the
+    request body.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        code: str,
+        message: str,
+        status_code: Optional[int] = None,
+        why: Optional[str] = None,
+        fix: Optional[str] = None,
+        docs_url: Optional[str] = None,
+        field: Optional[str] = None,
+        retry_after: Optional[float] = None,
+    ) -> None:
+        super().__init__(message)
+        self.name = name
+        self.code = code
+        self.message = message
+        self.status_code = status_code
+        self.why = why
+        self.fix = fix
+        self.docs_url = docs_url
+        self.field = field
+        self.retry_after = retry_after
+
+
+@dataclass(frozen=True)
+class EmailWarning:
+    code: str
+    message: str
+    fix: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class SendEmailResult:
+    """The queued email. ``id`` is its message ID."""
+
+    id: str
+    replayed: bool = False
+    warnings: tuple[EmailWarning, ...] = ()
+
+
+@dataclass(frozen=True)
+class EmailStatus:
+    """What happened to an email that ``send()`` queued.
+
+    ``status`` is one of:
+
+    - ``queued``: the email waits to go out.
+    - ``sent``: PostHog handed the email to the email provider.
+    - ``failed``: the email was not sent, and ``reason`` says why.
+    - ``delivered``: the recipient's mail server accepted the email.
+    - ``bounced`` and ``complained``: the recipient's mail provider reported
+      them after delivery.
+
+    Later SDK versions can see values this list does not have yet.
+    ``reason`` says why a failed email was not sent, such as
+    ``provider_error`` or ``recipient_suppressed``, or gives the bounce type of
+    a bounced email: ``hard``, ``soft`` or ``unknown``. It is ``None`` otherwise.
+    """
+
+    id: str
+    status: str
+    created_at: datetime
+    status_at: datetime
+    reason: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class _PreparedSend:
+    path: str
+    body: bytes
+    idempotency_key: str
+    max_retries: Optional[int] = None
+
+
+def _prepare_send(
+    to: str,
+    template_id: Union[str, UUID],
+    template_data: Optional[Mapping[str, Any]],
+    distinct_id: Optional[str],
+    idempotency_key: Optional[str],
+    max_retries: Optional[int] = None,
+) -> _PreparedSend:
+    if not isinstance(to, str):
+        raise TypeError("to must be one email address as a string.")
+    if not to.strip():
+        raise ValueError("to must not be empty.")
+    try:
+        template_uuid = (
+            template_id if isinstance(template_id, UUID) else UUID(template_id)
+        )
+    except (TypeError, ValueError, AttributeError):
+        raise ValueError("template_id must be the template's UUID.") from None
+    if template_data is not None and not isinstance(template_data, Mapping):
+        raise TypeError("template_data must be a mapping.")
+    if distinct_id is not None and (
+        not isinstance(distinct_id, str) or not distinct_id
+    ):
+        raise ValueError("distinct_id must be a nonempty string.")
+    if idempotency_key is None:
+        idempotency_key = str(uuid4())
+    elif not isinstance(idempotency_key, str) or not _IDEMPOTENCY_KEY.match(
+        idempotency_key
+    ):
+        raise ValueError(
+            "idempotency_key must be 1 to 255 visible ASCII characters without spaces."
+        )
+    if max_retries is not None and (
+        isinstance(max_retries, bool)
+        or not isinstance(max_retries, int)
+        or max_retries < 0
+    ):
+        raise ValueError("max_retries must be a nonnegative integer.")
+
+    payload: dict[str, Any] = {
+        "template": {"id": str(template_uuid)},
+        "to": to,
+        "message_data": clean(dict(template_data or {})),
+    }
+    if distinct_id is not None:
+        payload["identifiers"] = {"distinct_id": distinct_id}
+    return _PreparedSend(
+        path=_SEND_PATH,
+        body=json.dumps(payload, cls=DatetimeSerializer).encode("utf-8"),
+        idempotency_key=idempotency_key,
+        max_retries=max_retries,
+    )
+
+
+def _status_path(message_id: Union[str, UUID]) -> str:
+    try:
+        message_uuid = message_id if isinstance(message_id, UUID) else UUID(message_id)
+    except (TypeError, ValueError, AttributeError):
+        raise ValueError(
+            "message_id must be the message ID that send() returned."
+        ) from None
+    return _STATUS_PATH.format(message_id=message_uuid)
+
+
+def _validate_options(timeout: float, max_retries: int) -> None:
+    if (
+        isinstance(timeout, bool)
+        or not isinstance(timeout, (int, float))
+        or not math.isfinite(timeout)
+        or timeout <= 0
+    ):
+        raise ValueError("timeout must be a finite positive number of seconds.")
+    if (
+        isinstance(max_retries, bool)
+        or not isinstance(max_retries, int)
+        or max_retries < 0
+    ):
+        raise ValueError("max_retries must be a nonnegative integer.")
+
+
+def _text(value: Any) -> Optional[str]:
+    return value if isinstance(value, str) and value else None
+
+
+def _error_name(status: Optional[int], code: str) -> str:
+    if code == "missing_secret_key" or status == 401:
+        return "missing_api_key"
+    if status is None:
+        return "service_unavailable" if code == "network_error" else "application_error"
+    if status == 400:
+        return "validation_error"
+    if status == 403:
+        return "invalid_permission"
+    if status == 404:
+        return "not_found"
+    if status == 409:
+        return (
+            "validation_error"
+            if code == "template_outdated"
+            else "concurrent_idempotent_requests"
+        )
+    if status == 422:
+        # The template send route also answers 422 for send checks such as recipient_suppressed.
+        return (
+            "invalid_idempotent_request"
+            if code == "idempotency_key_reused"
+            else "validation_error"
+        )
+    if status == 429:
+        return (
+            "monthly_quota_exceeded" if code in _QUOTA_CODES else "rate_limit_exceeded"
+        )
+    if status == 503:
+        return "service_unavailable"
+    return "application_error"
+
+
+def _sdk_error(code: str, message: str, status: Optional[int] = None) -> EmailError:
+    return EmailError(
+        name=_error_name(status, code), code=code, message=message, status_code=status
+    )
+
+
+def _retry_after(header: Optional[str]) -> Optional[float]:
+    seconds = _parse_retry_after(header)
+    if seconds is None or not math.isfinite(seconds):
+        return None
+    return max(0.0, seconds)
+
+
+def _parse_response(
+    status: int, payload: Any, retry_after_header: Optional[str]
+) -> SendEmailResult:
+    fields = payload if isinstance(payload, dict) else {}
+    if 200 <= status < 300:
+        message_id = _text(fields.get("message_id"))
+        if message_id is None:
+            raise _sdk_error(
+                "api_error", "PostHog answered without a message ID.", status
+            )
+        warnings = fields.get("warnings")
+        return SendEmailResult(
+            id=message_id,
+            replayed=fields.get("replayed") is True,
+            warnings=tuple(
+                EmailWarning(
+                    code=_text(warning.get("code")) or "warning",
+                    message=_text(warning.get("detail"))
+                    or _text(warning.get("message"))
+                    or "",
+                    fix=_text(warning.get("fix")),
+                )
+                for warning in (warnings if isinstance(warnings, list) else [])
+                if isinstance(warning, dict)
+            ),
+        )
+    raise _response_error(fields, status, retry_after_header)
+
+
+def _timestamp(value: Any) -> Optional[datetime]:
+    text = _text(value)
+    if text is None:
+        return None
+    try:
+        # fromisoformat reads a trailing Z only from Python 3.11.
+        return datetime.fromisoformat(
+            text[:-1] + "+00:00" if text.endswith("Z") else text
+        )
+    except ValueError:
+        return None
+
+
+def _parse_status_response(
+    status: int, payload: Any, retry_after_header: Optional[str]
+) -> EmailStatus:
+    fields = payload if isinstance(payload, dict) else {}
+    if not 200 <= status < 300:
+        raise _response_error(fields, status, retry_after_header)
+    message_id = _text(fields.get("id"))
+    delivery_status = _text(fields.get("status"))
+    created_at = _timestamp(fields.get("created_at"))
+    status_at = _timestamp(fields.get("status_at"))
+    if (
+        message_id is None
+        or delivery_status is None
+        or created_at is None
+        or status_at is None
+    ):
+        raise _sdk_error(
+            "api_error", "PostHog answered without an email status.", status
+        )
+    return EmailStatus(
+        id=message_id,
+        status=delivery_status,
+        created_at=created_at,
+        status_at=status_at,
+        reason=_text(fields.get("reason")),
+    )
+
+
+def _response_error(
+    fields: Mapping[str, Any], status: int, retry_after_header: Optional[str]
+) -> EmailError:
+    code = _text(fields.get("code")) or "api_error"
+    return EmailError(
+        name=_error_name(status, code),
+        code=code,
+        message=_text(fields.get("detail")) or f"PostHog answered HTTP {status}.",
+        status_code=status,
+        why=_text(fields.get("why")),
+        fix=_text(fields.get("fix")),
+        docs_url=_text(fields.get("docs_url")),
+        field=_text(fields.get("attr")),
+        retry_after=_retry_after(retry_after_header),
+    )
+
+
+def _is_retryable(error: EmailError) -> bool:
+    # A send carries an idempotency key, so a retry can't queue a second email. A status read changes nothing.
+    if error.status_code is None:
+        return error.code == "network_error"
+    if error.status_code == 409:
+        return error.code in _IN_FLIGHT_CODES
+    if error.status_code == 429:
+        return error.code not in _QUOTA_CODES
+    return error.status_code == 503
+
+
+def _retry_delay(error: EmailError, attempt: int, max_retries: int) -> Optional[float]:
+    if attempt >= max_retries or not _is_retryable(error):
+        return None
+    # Retrying before a longer Retry-After would break the server's rate limit.
+    if error.retry_after is not None and error.retry_after > _MAX_RETRY_DELAY:
+        return None
+    backoff = min(_MAX_RETRY_DELAY, 2.0**attempt * random.uniform(0.8, 1.2))
+    return max(backoff, error.retry_after or 0.0)
+
+
+def _no_op() -> None:
+    pass
+
+
+def _log_warnings(result: SendEmailResult) -> None:
+    for warning in result.warnings:
+        log.warning("PostHog email warning %s: %s", warning.code, warning.message)
+
+
+def _headers(secret_key: str, idempotency_key: Optional[str]) -> dict[str, str]:
+    headers = {
+        "Authorization": f"Bearer {secret_key}",
+        "Accept": "application/json",
+        "User-Agent": f"posthog-python/{VERSION}",
+    }
+    if idempotency_key is not None:
+        headers["Content-Type"] = "application/json"
+        headers["Idempotency-Key"] = idempotency_key
+    return headers
+
+
+_SEND_NOT_DONE = "no email was sent"
+_GET_NOT_DONE = "no email status was read"
+_SEND_KEY_NEEDED = "Sending email needs secret_key, a project secret API key with the hog_flow:write scope."
+_GET_KEY_NEEDED = (
+    "Reading an email status needs secret_key, a project secret API key with the "
+    "hog_flow:read or hog_flow:write scope."
+)
+_ResultT = TypeVar("_ResultT")
+_Parse = Callable[[int, Any, Optional[str]], _ResultT]
+
+
+class _BearerAuth(requests.auth.AuthBase):
+    def __init__(self, headers: dict[str, str]) -> None:
+        self._headers = headers
+
+    def __call__(self, request: requests.PreparedRequest) -> requests.PreparedRequest:
+        # Setting auth explicitly stops requests from substituting .netrc credentials.
+        request.headers.update(self._headers)
+        return request
+
+
+class _EmailsBase:
+    def __init__(
+        self,
+        secret_key: Optional[str],
+        *,
+        host: Optional[str],
+        timeout: float,
+        max_retries: int,
+        disabled: bool,
+    ) -> None:
+        _validate_options(timeout, max_retries)
+        self.secret_key = secret_key.strip() if isinstance(secret_key, str) else None
+        self.host = determine_app_host(host)
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.disabled = disabled
+        self._parent_disabled: Callable[[], bool] = lambda: False
+        self._admit: Callable[[], Optional[Callable[[], None]]] = lambda: _no_op
+        self._host_error: Optional[str] = None
+
+    def _is_disabled(self) -> bool:
+        return self.disabled or self._parent_disabled()
+
+    def _start(self, not_done: str) -> Callable[[], None]:
+        if self._is_disabled():
+            raise _sdk_error(
+                "client_disabled", f"The PostHog client is disabled, so {not_done}."
+            )
+        finish = self._admit()
+        if finish is None:
+            raise _sdk_error(
+                "client_closed", f"The PostHog client is shut down, so {not_done}."
+            )
+        return finish
+
+    def _secret_key(self, key_needed: str) -> str:
+        if self._host_error:
+            raise _sdk_error("missing_app_host", self._host_error)
+        if not self.secret_key:
+            raise _sdk_error("missing_secret_key", key_needed)
+        return self.secret_key
+
+
+class Emails(_EmailsBase):
+    """Sends transactional email from PostHog email templates.
+
+    ``host`` is your PostHog app host. PostHog Cloud ingestion hosts map to the
+    app host, so ``us.i.posthog.com`` sends to ``us.posthog.com``. Any other
+    host is used as given.
+
+    Each send retries network errors, rate limits and an unavailable service up
+    to ``max_retries`` times, with the same idempotency key. Set
+    ``max_retries=0`` when a job runner already retries the send. ``timeout``
+    is in seconds, per request. Pass ``session`` to send through your own
+    ``requests.Session``, for example a test double.
+    """
+
+    def __init__(
+        self,
+        secret_key: Optional[str],
+        *,
+        host: Optional[str] = None,
+        timeout: float = 15,
+        max_retries: int = 2,
+        disabled: bool = False,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        super().__init__(
+            secret_key,
+            host=host,
+            timeout=timeout,
+            max_retries=max_retries,
+            disabled=disabled,
+        )
+        self._session: Optional[requests.Session] = session
+        self._owns_session = session is None
+        self._session_lock = threading.Lock()
+
+    def send(
+        self,
+        *,
+        to: str,
+        template_id: Union[str, UUID],
+        template_data: Optional[Mapping[str, Any]] = None,
+        distinct_id: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        max_retries: Optional[int] = None,
+    ) -> SendEmailResult:
+        """Queue one email from a transactional email template.
+
+        Args:
+            to: One recipient email address.
+            template_id: The UUID of a template made transactional in PostHog.
+            template_data: Values for the template's ``{{ variables.* }}``
+                placeholders. Values are encoded the way capture encodes
+                properties.
+            distinct_id: The recipient's distinct ID in your product. The
+                email's events go to this person. Without it, they go to a
+                person whose distinct ID is the email address.
+            idempotency_key: 1 to 255 visible ASCII characters. A send with a
+                key that PostHog has already accepted queues nothing and returns
+                the first send's result. Without it, the client makes a key
+                that covers its own retries. Pass a key derived from what the
+                email is for, such as ``welcome:user_123``, to cover retries
+                outside this call, too.
+            max_retries: Overrides the client's maximum number of retries for
+                this send. ``0`` turns retries off.
+
+        Returns:
+            The queued email. A result means PostHog queued the email, not that
+            it was delivered.
+
+        Raises:
+            EmailError: PostHog did not queue the email, or the client could
+                not tell whether it did.
+            TypeError, ValueError: An argument has the wrong type or format.
+
+        Examples:
+            ```python
+            emails.send(
+                to="user@example.com",
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                template_data={"name": "Ada"},
+                distinct_id="user_123",
+                idempotency_key="welcome:user_123",
+            )
+            ```
+        """
+        prepared = _prepare_send(
+            to, template_id, template_data, distinct_id, idempotency_key, max_retries
+        )
+        finish = self._start(_SEND_NOT_DONE)
+        try:
+            headers = _headers(
+                self._secret_key(_SEND_KEY_NEEDED), prepared.idempotency_key
+            )
+            result = self._call(
+                "POST",
+                prepared.path,
+                prepared.body,
+                headers,
+                _parse_response,
+                prepared.max_retries,
+            )
+        finally:
+            finish()
+        _log_warnings(result)
+        return result
+
+    def get(self, message_id: Union[str, UUID]) -> EmailStatus:
+        """Read what happened to an email that :meth:`send` queued.
+
+        Args:
+            message_id: The ``id`` of the :class:`SendEmailResult` that
+                :meth:`send` returned.
+
+        Returns:
+            The email's latest status, for 30 days after the send.
+
+        Raises:
+            EmailError: PostHog did not answer with a status. ``code`` is
+                ``not_found`` for an unknown ID, an email older than 30 days,
+                or for a few seconds after the send.
+            ValueError: ``message_id`` is not a message ID.
+
+        Examples:
+            ```python
+            result = emails.send(to="user@example.com", template_id="...")
+            status = emails.get(result.id)
+            if status.status == "bounced":
+                print(status.reason)
+            ```
+        """
+        path = _status_path(message_id)
+        finish = self._start(_GET_NOT_DONE)
+        try:
+            headers = _headers(self._secret_key(_GET_KEY_NEEDED), None)
+            return self._call("GET", path, None, headers, _parse_status_response)
+        finally:
+            finish()
+
+    def _call(
+        self,
+        method: str,
+        path: str,
+        body: Optional[bytes],
+        headers: dict[str, str],
+        parse: _Parse[_ResultT],
+        max_retries: Optional[int] = None,
+    ) -> _ResultT:
+        auth = _BearerAuth(headers)
+        session = self._get_session()
+        url = self.host + path
+        retries = self.max_retries if max_retries is None else max_retries
+        for attempt in range(retries + 1):
+            try:
+                response = session.request(
+                    method,
+                    url,
+                    data=body,
+                    auth=auth,
+                    timeout=self.timeout,
+                    allow_redirects=False,
+                )
+                try:
+                    try:
+                        payload = response.json()
+                    except ValueError:
+                        payload = None
+                    return parse(
+                        response.status_code,
+                        payload,
+                        response.headers.get("Retry-After"),
+                    )
+                finally:
+                    response.close()
+            except requests.exceptions.RequestException as exc:
+                error = _sdk_error("network_error", "The request to PostHog failed.")
+                error.__cause__ = exc
+            except EmailError as exc:
+                error = exc
+            delay = _retry_delay(error, attempt, retries)
+            if delay is None:
+                raise error
+            time.sleep(delay)
+        raise AssertionError("unreachable")
+
+    def close(self) -> None:
+        """Close the HTTP connections this client opened. A ``session`` you passed in stays open."""
+        with self._session_lock:
+            if self._session is not None and self._owns_session:
+                self._session.close()
+                self._session = None
+
+    def __enter__(self) -> Emails:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+    def _get_session(self) -> requests.Session:
+        with self._session_lock:
+            if self._session is None:
+                session = requests.Session()
+                session.mount("https://", requests.adapters.HTTPAdapter(max_retries=0))
+                session.mount("http://", requests.adapters.HTTPAdapter(max_retries=0))
+                self._session = session
+            return self._session
+
+
+class AsyncEmails(_EmailsBase):
+    """The async counterpart of :class:`Emails`. Needs ``posthog[async]``.
+
+    Pass ``http_client`` to send through your own ``httpx.AsyncClient``, for
+    example one with an ``httpx.MockTransport`` in tests.
+    """
+
+    def __init__(
+        self,
+        secret_key: Optional[str],
+        *,
+        host: Optional[str] = None,
+        timeout: float = 15,
+        max_retries: int = 2,
+        disabled: bool = False,
+        http_client: Any = None,
+    ) -> None:
+        super().__init__(
+            secret_key,
+            host=host,
+            timeout=timeout,
+            max_retries=max_retries,
+            disabled=disabled,
+        )
+        self._client: Any = http_client
+        self._owns_client = http_client is None
+
+    async def send(
+        self,
+        *,
+        to: str,
+        template_id: Union[str, UUID],
+        template_data: Optional[Mapping[str, Any]] = None,
+        distinct_id: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        max_retries: Optional[int] = None,
+    ) -> SendEmailResult:
+        """Queue one email from a transactional email template.
+
+        Takes the same arguments and raises the same errors as
+        :meth:`Emails.send`.
+
+        Examples:
+            ```python
+            await emails.send(
+                to="user@example.com",
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                template_data={"name": "Ada"},
+                distinct_id="user_123",
+            )
+            ```
+        """
+        prepared = _prepare_send(
+            to, template_id, template_data, distinct_id, idempotency_key, max_retries
+        )
+        finish = self._start(_SEND_NOT_DONE)
+        try:
+            headers = _headers(
+                self._secret_key(_SEND_KEY_NEEDED), prepared.idempotency_key
+            )
+            result = await self._call(
+                "POST",
+                prepared.path,
+                prepared.body,
+                headers,
+                _parse_response,
+                prepared.max_retries,
+            )
+        finally:
+            finish()
+        _log_warnings(result)
+        return result
+
+    async def get(self, message_id: Union[str, UUID]) -> EmailStatus:
+        """Read what happened to an email that :meth:`send` queued.
+
+        Takes the same argument and raises the same errors as
+        :meth:`Emails.get`.
+        """
+        path = _status_path(message_id)
+        finish = self._start(_GET_NOT_DONE)
+        try:
+            headers = _headers(self._secret_key(_GET_KEY_NEEDED), None)
+            return await self._call("GET", path, None, headers, _parse_status_response)
+        finally:
+            finish()
+
+    async def _call(
+        self,
+        method: str,
+        path: str,
+        body: Optional[bytes],
+        headers: dict[str, str],
+        parse: _Parse[_ResultT],
+        max_retries: Optional[int] = None,
+    ) -> _ResultT:
+        httpx, client = self._get_client()
+        url = self.host + path
+        retries = self.max_retries if max_retries is None else max_retries
+        for attempt in range(retries + 1):
+            try:
+                # An injected client may carry its own auth and timeout, so set both per request: auth=None keeps
+                # the secret key's Bearer header, and the request timeout applies whatever the client's default.
+                response = await client.request(
+                    method,
+                    url,
+                    content=body,
+                    headers=headers,
+                    auth=None,
+                    timeout=self.timeout,
+                )
+                try:
+                    try:
+                        payload = response.json()
+                    except ValueError:
+                        payload = None
+                    return parse(
+                        response.status_code,
+                        payload,
+                        response.headers.get("Retry-After"),
+                    )
+                finally:
+                    await response.aclose()
+            except httpx.RequestError as exc:
+                error = _sdk_error("network_error", "The request to PostHog failed.")
+                error.__cause__ = exc
+            except EmailError as exc:
+                error = exc
+            delay = _retry_delay(error, attempt, retries)
+            if delay is None:
+                raise error
+            await asyncio.sleep(delay)
+        raise AssertionError("unreachable")
+
+    async def aclose(self) -> None:
+        """Close the HTTP connections this client opened. An ``http_client`` you passed in stays open."""
+        if self._client is not None and self._owns_client:
+            client, self._client = self._client, None
+            await client.aclose()
+
+    async def __aenter__(self) -> AsyncEmails:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    def _get_client(self) -> tuple[Any, Any]:
+        try:
+            httpx = importlib.import_module("httpx")
+        except ImportError:
+            raise RuntimeError(
+                "Async email sending needs httpx. Install it with `posthog[async]`."
+            ) from None
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=self.timeout, follow_redirects=False
+            )
+        return httpx, self._client
+
+
+_EmailsT = TypeVar("_EmailsT", bound=_EmailsBase)
+
+
+def _client_emails(
+    factory: Callable[..., _EmailsT],
+    secret_key: Optional[str],
+    client_host: Optional[str],
+    is_disabled: Callable[[], bool],
+    admit: Callable[[], Optional[Callable[[], None]]],
+    *,
+    app_host: Optional[str],
+    timeout: float,
+    max_retries: int,
+) -> _EmailsT:
+    if app_host:
+        emails = factory(
+            secret_key, host=app_host, timeout=timeout, max_retries=max_retries
+        )
+        emails._parent_disabled = is_disabled
+        emails._admit = admit
+        return emails
+    inferred_host = determine_app_host(client_host)
+    is_cloud = inferred_host in (US_APP_ENDPOINT, EU_APP_ENDPOINT)
+    emails = factory(
+        secret_key,
+        host=inferred_host if is_cloud else None,
+        timeout=timeout,
+        max_retries=max_retries,
+    )
+    if not is_cloud:
+        # A custom host is often an ingestion proxy, which must not receive the secret key.
+        emails._host_error = (
+            "The client's host is not PostHog Cloud, so the client can't tell where to send email. "
+            "Set app_host to your PostHog app host on the client."
+        )
+    emails._parent_disabled = is_disabled
+    emails._admit = admit
+    return emails
diff --git a/posthog/request.py b/posthog/request.py
index 9b7b1b1b2..f1816444d 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -186,6 +186,8 @@ def disable_connection_reuse() -> None:
 
 US_INGESTION_ENDPOINT = "https://us.i.posthog.com"
 EU_INGESTION_ENDPOINT = "https://eu.i.posthog.com"
+US_APP_ENDPOINT = "https://us.posthog.com"
+EU_APP_ENDPOINT = "https://eu.posthog.com"
 DEFAULT_HOST = US_INGESTION_ENDPOINT
 USER_AGENT = "posthog-python/" + VERSION
 
@@ -213,6 +215,17 @@ def determine_server_host(host: Optional[str]) -> str:
         return host_or_default
 
 
+def determine_app_host(host: Optional[str]) -> str:
+    """Determines the host for app API calls. PostHog Cloud ingestion hosts don't serve them."""
+    trimmed_host = remove_trailing_slash(normalize_host(host))
+    if trimmed_host in (US_INGESTION_ENDPOINT, "https://app.posthog.com"):
+        return US_APP_ENDPOINT
+    elif trimmed_host == EU_INGESTION_ENDPOINT:
+        return EU_APP_ENDPOINT
+    else:
+        return trimmed_host
+
+
 def post(
     api_key: str,
     host: Optional[str] = None,
diff --git a/posthog/test/test_emails.py b/posthog/test/test_emails.py
new file mode 100644
index 000000000..0d2099a86
--- /dev/null
+++ b/posthog/test/test_emails.py
@@ -0,0 +1,574 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import Any, Optional, Union
+from unittest import mock
+
+import httpx
+import pytest
+import requests
+from parameterized import parameterized
+
+from posthog import AsyncPosthog, Posthog
+from posthog.emails import AsyncEmails, EmailError, Emails, EmailStatus
+from posthog.version import VERSION
+
+SECRET_KEY = "phs_test_secret"
+TEMPLATE_ID = "0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b"
+SEND_URL = "https://us.posthog.com/api/projects/@current/messaging/send/email/"
+MESSAGE_ID = "01a18356-c56c-0001-e494-7666bc915188"
+STATUS_URL = (
+    f"https://us.posthog.com/api/projects/@current/messaging/emails/{MESSAGE_ID}/"
+)
+
+Reply = Union[Exception, tuple[int, Optional[dict[str, Any]], dict[str, str]]]
+
+
+def accepted(message_id: str = "msg_1", **fields: Any) -> Reply:
+    return (202, {"message_id": message_id, **fields}, {})
+
+
+def rejected(status: int, code: Optional[str] = None, **headers: str) -> Reply:
+    body = (
+        {"type": "invalid_request", "code": code, "detail": "Nope."} if code else None
+    )
+    return (status, body, headers)
+
+
+class FakeAdapter(requests.adapters.BaseAdapter):
+    def __init__(self, replies: list[Reply]) -> None:
+        super().__init__()
+        self.replies = list(replies)
+        self.requests: list[requests.PreparedRequest] = []
+
+    def send(
+        self, request: requests.PreparedRequest, **kwargs: Any
+    ) -> requests.Response:
+        self.requests.append(request)
+        reply = self.replies.pop(0)
+        if isinstance(reply, Exception):
+            raise reply
+        status, body, headers = reply
+        response = requests.Response()
+        response.status_code = status
+        response._content = b"" if body is None else json.dumps(body).encode()
+        response.headers.update(headers)
+        response.request = request
+        response.url = request.url or ""
+        return response
+
+    def close(self) -> None:
+        pass
+
+
+def emails_with(replies: list[Reply], **options: Any) -> tuple[Emails, FakeAdapter]:
+    adapter = FakeAdapter(replies)
+    session = requests.Session()
+    session.mount("https://", adapter)
+    return Emails(SECRET_KEY, session=session, **options), adapter
+
+
+def response(status: int, body: dict[str, Any]) -> requests.Response:
+    reply = requests.Response()
+    reply.status_code = status
+    reply._content = json.dumps(body).encode()
+    return reply
+
+
+def send(emails: Emails, **overrides: Any):
+    return emails.send(
+        **{"to": "user@example.com", "template_id": TEMPLATE_ID, **overrides}
+    )
+
+
+@pytest.fixture(autouse=True)
+def no_sleep():
+    with (
+        mock.patch("posthog.emails.time.sleep") as sleep,
+        mock.patch("posthog.emails.random.uniform", return_value=1.0),
+    ):
+        yield sleep
+
+
+@parameterized.expand(
+    [
+        (
+            "with_distinct_id",
+            {"distinct_id": "user_123"},
+            {"identifiers": {"distinct_id": "user_123"}},
+        ),
+        ("without_distinct_id", {}, {}),
+    ]
+)
+def test_send_posts_the_template_to_the_app_host(_name, overrides, extra_body):
+    emails, adapter = emails_with([accepted("msg_1")])
+
+    result = send(
+        emails,
+        template_data={
+            "total": Decimal("19.5"),
+            "expires_at": datetime(2026, 11, 20, tzinfo=timezone.utc),
+        },
+        idempotency_key="welcome:user_123",
+        **overrides,
+    )
+
+    assert result.id == "msg_1"
+    assert result.replayed is False
+    [request] = adapter.requests
+    assert (request.method, request.url) == ("POST", SEND_URL)
+    assert request.headers["Authorization"] == f"Bearer {SECRET_KEY}"
+    assert request.headers["Idempotency-Key"] == "welcome:user_123"
+    assert request.headers["User-Agent"] == f"posthog-python/{VERSION}"
+    assert json.loads(request.body) == {
+        "template": {"id": TEMPLATE_ID},
+        "to": "user@example.com",
+        "message_data": {"total": 19.5, "expires_at": "2026-11-20T00:00:00+00:00"},
+        **extra_body,
+    }
+
+
+@parameterized.expand(
+    [
+        ("default", None, "https://us.posthog.com"),
+        ("us_ingestion", "https://us.i.posthog.com", "https://us.posthog.com"),
+        ("eu_ingestion", "https://eu.i.posthog.com/", "https://eu.posthog.com"),
+        ("legacy_app", "https://app.posthog.com", "https://us.posthog.com"),
+    ]
+)
+def test_sends_go_to_the_app_host(_name, host, expected):
+    assert Emails(SECRET_KEY, host=host).host == expected
+    # The client turns app hosts into ingestion hosts, so the emails API maps them back.
+    client_host = host or "https://us.posthog.com"
+    client = Posthog(
+        "phc_test", host=client_host, secret_key=SECRET_KEY, sync_mode=True
+    )
+    assert client.emails.host == expected
+
+
+def test_a_client_with_a_custom_host_never_sends_it_the_secret_key():
+    assert (
+        Emails(SECRET_KEY, host="https://ph.example.com/").host
+        == "https://ph.example.com"
+    )
+    client = Posthog(
+        "phc_test", host="https://ph.example.com", secret_key=SECRET_KEY, sync_mode=True
+    )
+
+    with mock.patch.object(requests.Session, "request") as request:
+        with pytest.raises(EmailError) as raised:
+            send(client.emails)
+
+    assert raised.value.code == "missing_app_host"
+    request.assert_not_called()
+
+
+def test_client_email_options_set_the_host_timeout_and_retries():
+    client = Posthog(
+        "phc_test",
+        host="https://ph.example.com",
+        secret_key=SECRET_KEY,
+        sync_mode=True,
+        app_host="https://posthog.example.com/",
+        email_request_timeout_seconds=3,
+        email_request_max_retries=0,
+    )
+    unavailable = response(503, {"code": "delivery_unavailable"})
+
+    with mock.patch.object(
+        requests.Session, "request", return_value=unavailable
+    ) as request:
+        with pytest.raises(EmailError):
+            send(client.emails)
+
+    request.assert_called_once()
+    assert request.call_args.args[1].startswith("https://posthog.example.com/api/")
+    assert request.call_args.kwargs["timeout"] == 3
+
+
+@parameterized.expand(
+    [
+        ("rate_limited", rejected(429, "throttled"), True),
+        ("over_quota", rejected(429, "quota_limited"), False),
+        ("service_unavailable", rejected(503, "delivery_unavailable"), True),
+        ("same_key_in_flight", rejected(409, "idempotency_key_in_flight"), True),
+        ("template_outdated", rejected(409, "template_outdated"), False),
+        ("invalid_recipient", rejected(400, "invalid_recipient"), False),
+        ("server_error", rejected(500), False),
+        ("connection_error", requests.exceptions.ConnectionError("down"), True),
+        ("read_timeout", requests.exceptions.ReadTimeout("slow"), True),
+    ]
+)
+def test_retries_only_what_waiting_can_fix(_name, first_reply, retried):
+    emails, adapter = emails_with([first_reply, accepted()])
+
+    if retried:
+        assert send(emails).id == "msg_1"
+        first, second = adapter.requests
+        assert first.headers["Idempotency-Key"] == second.headers["Idempotency-Key"]
+    else:
+        with pytest.raises(EmailError):
+            send(emails)
+        assert len(adapter.requests) == 1
+
+
+@parameterized.expand(
+    [
+        (400, "invalid_recipient", "validation_error"),
+        (401, "authentication_failed", "missing_api_key"),
+        (403, "permission_denied", "invalid_permission"),
+        (404, "not_found", "not_found"),
+        (409, "idempotency_key_in_flight", "concurrent_idempotent_requests"),
+        (409, "template_outdated", "validation_error"),
+        (422, "idempotency_key_reused", "invalid_idempotent_request"),
+        (422, "recipient_suppressed", "validation_error"),
+        (429, "throttled", "rate_limit_exceeded"),
+        (429, "quota_limited", "monthly_quota_exceeded"),
+        (503, "delivery_unavailable", "service_unavailable"),
+        (500, None, "application_error"),
+    ]
+)
+def test_errors_keep_posthogs_code_and_resends_name(status, code, name):
+    emails, _ = emails_with([rejected(status, code)], max_retries=0)
+
+    with pytest.raises(EmailError) as raised:
+        send(emails)
+
+    assert (raised.value.status_code, raised.value.code, raised.value.name) == (
+        status,
+        code or "api_error",
+        name,
+    )
+    assert SECRET_KEY not in str(raised.value)
+
+
+def test_network_failure_after_retries_is_service_unavailable():
+    failure = requests.exceptions.ConnectionError("down")
+    emails, adapter = emails_with([failure, failure, failure])
+
+    with pytest.raises(EmailError) as raised:
+        send(emails)
+
+    assert len(adapter.requests) == 3
+    assert (raised.value.code, raised.value.name) == (
+        "network_error",
+        "service_unavailable",
+    )
+    assert isinstance(raised.value.__cause__, requests.exceptions.ConnectionError)
+
+
+def test_waits_for_retry_after_and_gives_up_on_a_longer_one(no_sleep):
+    emails, adapter = emails_with(
+        [rejected(429, "throttled", **{"Retry-After": "5"}), accepted()]
+    )
+    send(emails)
+    no_sleep.assert_called_once_with(5.0)
+
+    emails, adapter = emails_with(
+        [rejected(429, "throttled", **{"Retry-After": "120"})]
+    )
+    with pytest.raises(EmailError) as raised:
+        send(emails)
+    assert raised.value.retry_after == 120.0
+    assert len(adapter.requests) == 1
+
+
+@parameterized.expand(
+    [
+        ("client_option", {"max_retries": 0}, {}, 1),
+        ("per_send_override", {}, {"max_retries": 0}, 1),
+        ("per_send_override_above_client", {"max_retries": 0}, {"max_retries": 1}, 2),
+    ]
+)
+def test_max_retries_zero_leaves_retries_to_the_caller(
+    _name, client_options, send_options, requests_made
+):
+    emails, adapter = emails_with(
+        [rejected(503, "delivery_unavailable")] * 3, **client_options
+    )
+
+    with pytest.raises(EmailError):
+        send(emails, **send_options)
+
+    assert len(adapter.requests) == requests_made
+
+
+def test_an_acceptance_without_a_message_id_is_not_retried():
+    emails, adapter = emails_with([(202, {}, {}), accepted()])
+
+    with pytest.raises(EmailError) as raised:
+        send(emails)
+
+    assert raised.value.code == "api_error"
+    assert len(adapter.requests) == 1
+
+
+def test_replays_and_warnings_reach_the_caller(caplog):
+    warning = {
+        "code": "template_superseded",
+        "detail": "Newer content.",
+        "fix": "Upload.",
+    }
+    emails, _ = emails_with([accepted("msg_1", replayed=True, warnings=[warning])])
+
+    with caplog.at_level(logging.WARNING, logger="posthog"):
+        result = send(emails)
+
+    assert result.replayed is True
+    assert [(w.code, w.fix) for w in result.warnings] == [
+        ("template_superseded", "Upload.")
+    ]
+    assert "template_superseded" in caplog.text
+
+
+def test_missing_secret_key_fails_before_sending():
+    emails = Emails(None)
+
+    with mock.patch.object(requests.Session, "request") as request:
+        with pytest.raises(EmailError) as raised:
+            send(emails)
+
+    assert (raised.value.code, raised.value.name) == (
+        "missing_secret_key",
+        "missing_api_key",
+    )
+    request.assert_not_called()
+
+
+def test_a_disabled_client_sends_nothing():
+    client = Posthog("phc_test", secret_key=SECRET_KEY, sync_mode=True)
+    emails = client.emails
+
+    client.disabled = True
+    with mock.patch.object(requests.Session, "request") as request:
+        with pytest.raises(EmailError) as raised:
+            send(emails)
+
+    assert (raised.value.code, raised.value.name) == (
+        "client_disabled",
+        "application_error",
+    )
+    request.assert_not_called()
+
+
+def test_a_shut_down_client_sends_no_email():
+    client = Posthog("phc_test", secret_key=SECRET_KEY, sync_mode=True)
+    emails = client.emails
+
+    client.shutdown()
+
+    with mock.patch.object(requests.Session, "request") as request:
+        for handle in (emails, client.emails):
+            with pytest.raises(EmailError) as raised:
+                send(handle)
+            assert raised.value.code == "client_closed"
+    request.assert_not_called()
+    assert emails._session is None
+
+
+@parameterized.expand(
+    [
+        ("several_recipients", {"to": ["a@example.com", "b@example.com"]}, TypeError),
+        ("empty_recipient", {"to": " "}, ValueError),
+        ("template_name", {"template_id": "welcome"}, ValueError),
+        ("template_data_list", {"template_data": [1, 2]}, TypeError),
+        ("key_with_space", {"idempotency_key": "welcome user"}, ValueError),
+        ("key_too_long", {"idempotency_key": "k" * 256}, ValueError),
+        ("negative_retries", {"max_retries": -1}, ValueError),
+    ]
+)
+def test_rejects_invalid_arguments_before_sending(_name, overrides, error):
+    emails, adapter = emails_with([])
+
+    with pytest.raises(error):
+        send(emails, **overrides)
+
+    assert adapter.requests == []
+
+
+@pytest.mark.asyncio
+async def test_async_send_retries_with_the_same_key():
+    seen: list[httpx.Request] = []
+    replies = [
+        httpx.Response(503, json={"code": "delivery_unavailable"}),
+        httpx.Response(202, json={"message_id": "msg_1"}),
+    ]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return replies.pop(0)
+
+    emails = AsyncEmails(
+        SECRET_KEY,
+        timeout=3,
+        http_client=httpx.AsyncClient(
+            transport=httpx.MockTransport(handler), auth=("user", "pass"), timeout=None
+        ),
+    )
+
+    with mock.patch("posthog.emails.asyncio.sleep") as sleep:
+        result = await emails.send(
+            to="user@example.com", template_id=TEMPLATE_ID, distinct_id="user_123"
+        )
+
+    assert result.id == "msg_1"
+    sleep.assert_awaited_once()
+    assert [str(request.url) for request in seen] == [SEND_URL, SEND_URL]
+    assert seen[0].headers["Idempotency-Key"] == seen[1].headers["Idempotency-Key"]
+    assert seen[0].headers["Authorization"] == f"Bearer {SECRET_KEY}"
+    assert seen[0].extensions["timeout"] == dict.fromkeys(
+        ["connect", "read", "write", "pool"], 3
+    )
+    assert json.loads(seen[0].content)["identifiers"] == {"distinct_id": "user_123"}
+
+
+@pytest.mark.asyncio
+async def test_async_disabled_client_sends_nothing():
+    handler = mock.Mock(side_effect=AssertionError("a disabled client sent a request"))
+    emails = AsyncEmails(
+        SECRET_KEY,
+        disabled=True,
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+    )
+
+    with pytest.raises(EmailError) as raised:
+        await emails.send(to="user@example.com", template_id=TEMPLATE_ID)
+
+    assert raised.value.code == "client_disabled"
+    handler.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_async_shutdown_waits_for_a_send_in_flight_and_then_refuses_sends():
+    started, release = asyncio.Event(), asyncio.Event()
+    replies = [
+        httpx.Response(503, json={"code": "delivery_unavailable"}),
+        httpx.Response(202, json={"message_id": "msg_1"}),
+    ]
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        started.set()
+        await release.wait()
+        return replies.pop(0)
+
+    client = AsyncPosthog("phc_test", secret_key=SECRET_KEY)
+    emails = client.emails
+    emails._client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+
+    with mock.patch("posthog.emails._retry_delay", return_value=0.0):
+        sending = asyncio.create_task(
+            emails.send(to="user@example.com", template_id=TEMPLATE_ID)
+        )
+        await started.wait()
+        shutting_down = asyncio.create_task(client.shutdown())
+        for _ in range(5):
+            await asyncio.sleep(0)
+        assert not shutting_down.done()
+        release.set()
+
+        assert (await sending).id == "msg_1"
+        await shutting_down
+
+    assert emails._client is None
+    with pytest.raises(EmailError) as raised:
+        await emails.send(to="user@example.com", template_id=TEMPLATE_ID)
+    assert raised.value.code == "client_closed"
+
+
+def status_reply(**fields: Any) -> Reply:
+    body = {
+        "id": MESSAGE_ID,
+        "status": "bounced",
+        "created_at": "2026-10-28T16:27:44.364000Z",
+        "status_at": "2026-10-28T16:30:02.100000Z",
+        "reason": "hard",
+        **fields,
+    }
+    return (200, body, {})
+
+
+def test_get_reads_the_status_of_a_sent_email_from_the_app_host():
+    emails, adapter = emails_with([status_reply()])
+
+    status = emails.get(MESSAGE_ID.upper())
+
+    assert status == EmailStatus(
+        id=MESSAGE_ID,
+        status="bounced",
+        created_at=datetime(2026, 10, 28, 16, 27, 44, 364000, tzinfo=timezone.utc),
+        status_at=datetime(2026, 10, 28, 16, 30, 2, 100000, tzinfo=timezone.utc),
+        reason="hard",
+    )
+    [request] = adapter.requests
+    assert (request.method, request.url, request.body) == ("GET", STATUS_URL, None)
+    assert request.headers["Authorization"] == f"Bearer {SECRET_KEY}"
+    assert "Idempotency-Key" not in request.headers
+
+
+@parameterized.expand(
+    [
+        (
+            "unknown_id_without_a_retry",
+            [rejected(404, "not_found")],
+            MESSAGE_ID,
+            "not_found",
+            1,
+        ),
+        (
+            "reply_without_a_status",
+            [status_reply(status=None)],
+            MESSAGE_ID,
+            "api_error",
+            1,
+        ),
+    ]
+)
+def test_get_reports_a_missing_status(_name, replies, message_id, code, requests_made):
+    emails, adapter = emails_with(replies)
+
+    with pytest.raises(EmailError) as raised:
+        emails.get(message_id)
+
+    assert raised.value.code == code
+    assert len(adapter.requests) == requests_made
+
+
+def test_get_rejects_an_id_that_is_not_a_message_id_before_a_request():
+    emails, adapter = emails_with([])
+
+    with pytest.raises(ValueError):
+        emails.get("msg_1")
+
+    assert adapter.requests == []
+
+
+@pytest.mark.asyncio
+async def test_async_get_retries_an_unavailable_service():
+    seen: list[httpx.Request] = []
+    replies = [
+        httpx.Response(503, json={"code": "delivery_unavailable"}),
+        httpx.Response(
+            200, json={**status_reply()[1], "status": "sent", "reason": None}
+        ),
+    ]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return replies.pop(0)
+
+    emails = AsyncEmails(
+        SECRET_KEY,
+        http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+    )
+
+    with mock.patch("posthog.emails.asyncio.sleep"):
+        status = await emails.get(MESSAGE_ID)
+
+    assert (status.status, status.reason) == ("sent", None)
+    assert [(request.method, str(request.url)) for request in seen] == [
+        ("GET", STATUS_URL)
+    ] * 2
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 63ce6a504..3eadb81bd 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -246,6 +246,7 @@ alias posthog.client.DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS -> posthog.exception
 alias posthog.client.DEFAULT_CODE_VARIABLES_MASK_PATTERNS -> posthog.exception_utils.DEFAULT_CODE_VARIABLES_MASK_PATTERNS
 alias posthog.client.DEFAULT_CODE_VARIABLES_MASK_URL_CREDENTIALS -> posthog.exception_utils.DEFAULT_CODE_VARIABLES_MASK_URL_CREDENTIALS
 alias posthog.client.EVENTS_ENDPOINT -> posthog.request.EVENTS_ENDPOINT
+alias posthog.client.Emails -> posthog.emails.Emails
 alias posthog.client.ExceptionArg -> posthog.args.ExceptionArg
 alias posthog.client.ExceptionCapture -> posthog.exception_capture.ExceptionCapture
 alias posthog.client.FeatureFlag -> posthog.types.FeatureFlag
@@ -730,6 +731,7 @@ attribute posthog.args.OptionalSetArgs.properties: NotRequired[Optional[Dict[str
 attribute posthog.args.OptionalSetArgs.timestamp: NotRequired[Optional[Union[datetime, str]]]
 attribute posthog.args.OptionalSetArgs.uuid: NotRequired[Optional[Union[str, UUID]]]
 attribute posthog.async_client.AsyncClient.api_key = (project_api_key or '').strip()
+attribute posthog.async_client.AsyncClient.app_host = app_host
 attribute posthog.async_client.AsyncClient.before_send = before_send
 attribute posthog.async_client.AsyncClient.capture_compression = _resolve_capture_compression(capture_compression, gzip_fallback=gzip)
 attribute posthog.async_client.AsyncClient.capture_exception_code_variables = capture_exception_code_variables
@@ -743,6 +745,9 @@ attribute posthog.async_client.AsyncClient.debug = debug
 attribute posthog.async_client.AsyncClient.disable_geoip = disable_geoip
 attribute posthog.async_client.AsyncClient.disabled = disabled or not self.api_key
 attribute posthog.async_client.AsyncClient.distinct_ids_feature_flags_reported = SizeLimitedDict(_MAX_DICT_SIZE, set)
+attribute posthog.async_client.AsyncClient.email_request_max_retries = email_request_max_retries
+attribute posthog.async_client.AsyncClient.email_request_timeout_seconds = email_request_timeout_seconds
+attribute posthog.async_client.AsyncClient.emails: AsyncEmails
 attribute posthog.async_client.AsyncClient.feature_flags_request_max_retries = max(0, feature_flags_request_max_retries)
 attribute posthog.async_client.AsyncClient.feature_flags_request_timeout_seconds = feature_flags_request_timeout_seconds
 attribute posthog.async_client.AsyncClient.gzip = gzip
@@ -780,6 +785,7 @@ attribute posthog.capture_v1.CaptureV1Error.drops = drops or []
 attribute posthog.capture_v1.CaptureV1Error.request_id = request_id
 attribute posthog.capture_v1.CaptureV1Error.retry_exhausted = retry_exhausted or []
 attribute posthog.client.Client.api_key = (project_api_key or '').strip()
+attribute posthog.client.Client.app_host = app_host
 attribute posthog.client.Client.capture_compression = _resolve_capture_compression(capture_compression, gzip_fallback=gzip)
 attribute posthog.client.Client.capture_exception_code_variables = capture_exception_code_variables
 attribute posthog.client.Client.capture_mode = _resolve_capture_mode(capture_mode)
@@ -794,6 +800,9 @@ attribute posthog.client.Client.debug = debug
 attribute posthog.client.Client.disable_geoip = disable_geoip
 attribute posthog.client.Client.disabled = disabled or not self.api_key
 attribute posthog.client.Client.distinct_ids_feature_flags_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
+attribute posthog.client.Client.email_request_max_retries = email_request_max_retries
+attribute posthog.client.Client.email_request_timeout_seconds = email_request_timeout_seconds
+attribute posthog.client.Client.emails: Emails
 attribute posthog.client.Client.enable_exception_autocapture = enable_exception_autocapture
 attribute posthog.client.Client.enable_exception_autocapture_rate_limiting = enable_exception_autocapture_rate_limiting
 attribute posthog.client.Client.enable_full_ai_capture = enable_full_ai_capture is True or _use_ai_lane is True or _enable_multimodal_capture is True
@@ -875,6 +884,26 @@ attribute posthog.debug = False
 attribute posthog.default_client = None
 attribute posthog.disable_geoip = True
 attribute posthog.disabled = False
+attribute posthog.emails.EmailError.code = code
+attribute posthog.emails.EmailError.docs_url = docs_url
+attribute posthog.emails.EmailError.field = field
+attribute posthog.emails.EmailError.fix = fix
+attribute posthog.emails.EmailError.message = message
+attribute posthog.emails.EmailError.name = name
+attribute posthog.emails.EmailError.retry_after = retry_after
+attribute posthog.emails.EmailError.status_code = status_code
+attribute posthog.emails.EmailError.why = why
+attribute posthog.emails.EmailStatus.created_at: datetime
+attribute posthog.emails.EmailStatus.id: str
+attribute posthog.emails.EmailStatus.reason: Optional[str] = None
+attribute posthog.emails.EmailStatus.status: str
+attribute posthog.emails.EmailStatus.status_at: datetime
+attribute posthog.emails.EmailWarning.code: str
+attribute posthog.emails.EmailWarning.fix: Optional[str] = None
+attribute posthog.emails.EmailWarning.message: str
+attribute posthog.emails.SendEmailResult.id: str
+attribute posthog.emails.SendEmailResult.replayed: bool = False
+attribute posthog.emails.SendEmailResult.warnings: tuple[EmailWarning, ...] = ()
 attribute posthog.enable_exception_autocapture = False
 attribute posthog.enable_exception_autocapture_rate_limiting = False
 attribute posthog.enable_full_ai_capture = False
@@ -1105,6 +1134,7 @@ attribute posthog.request.APIError.message = message
 attribute posthog.request.APIError.retry_after = retry_after
 attribute posthog.request.APIError.status = status
 attribute posthog.request.DEFAULT_HOST = US_INGESTION_ENDPOINT
+attribute posthog.request.EU_APP_ENDPOINT = 'https://eu.posthog.com'
 attribute posthog.request.EU_INGESTION_ENDPOINT = 'https://eu.i.posthog.com'
 attribute posthog.request.EVENTS_ENDPOINT = '/batch/'
 attribute posthog.request.GetResponse.data: Any
@@ -1119,6 +1149,7 @@ attribute posthog.request.RequestsConnectionError = requests.exceptions.Connecti
 attribute posthog.request.RequestsTimeout = requests.exceptions.Timeout
 attribute posthog.request.SocketOptions = List[Tuple[int, int, Union[int, bytes]]]
 attribute posthog.request.USER_AGENT = 'posthog-python/' + VERSION
+attribute posthog.request.US_APP_ENDPOINT = 'https://us.posthog.com'
 attribute posthog.request.US_INGESTION_ENDPOINT = 'https://us.i.posthog.com'
 attribute posthog.secret_key = None
 attribute posthog.send = True
@@ -1289,15 +1320,21 @@ class posthog.ai.types.TokenUsage
 class posthog.ai.types.ToolInProgress 
 class posthog.args.OptionalCaptureArgs 
 class posthog.args.OptionalSetArgs 
-class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1)
+class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
 class posthog.async_client.AsyncPosthog 
 class posthog.bucketed_rate_limiter.BucketedRateLimiter(bucket_size: Number, refill_rate: Number, refill_interval_seconds: Number, on_bucket_rate_limited: Optional[Callable[[Hashable], None]] = None, clock: Callable[[], float] = time.monotonic)
 class posthog.capture_compression.CaptureCompression 
 class posthog.capture_mode.CaptureMode 
 class posthog.capture_v1.CaptureV1Error(status: int | str, message: str, *, retry_after: Optional[float] = None, request_id: Optional[str] = None, attempts: Optional[int] = None, retry_exhausted: Optional[list[str]] = None, drops: Optional[list[tuple[str, Optional[str]]]] = None)
-class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None)
+class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
 class posthog.consumer.Consumer(queue, api_key, flush_at=100, host=None, on_error=None, flush_interval=5.0, gzip=False, retries=10, timeout: float = 15, historical_migration=False, endpoint=EVENTS_ENDPOINT, max_msg_size=MAX_MSG_SIZE, capture_mode=CaptureMode.V0, capture_compression=CaptureCompression.NONE)
 class posthog.contexts.ContextScope(parent=None, fresh: bool = False, capture_exceptions: bool = True, client: Optional[Client] = None)
+class posthog.emails.AsyncEmails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, http_client: Any = None)
+class posthog.emails.EmailError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None)
+class posthog.emails.EmailStatus(id: str, status: str, created_at: datetime, status_at: datetime, reason: Optional[str] = None)
+class posthog.emails.EmailWarning(code: str, message: str, fix: Optional[str] = None)
+class posthog.emails.Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None)
+class posthog.emails.SendEmailResult(id: str, replayed: bool = False, warnings: tuple[EmailWarning, ...] = ())
 class posthog.exception_capture.ExceptionCapture(client: Client, rate_limiting_enabled=False, bucket_size=DEFAULT_BUCKET_SIZE, refill_rate=DEFAULT_REFILL_RATE, refill_interval_seconds=DEFAULT_REFILL_INTERVAL_SECONDS)
 class posthog.exception_utils.AnnotatedValue(value, metadata)
 class posthog.exception_utils.VariableSizeLimiter(max_size=DEFAULT_TOTAL_VARIABLES_SIZE_LIMIT)
@@ -1537,6 +1574,7 @@ function posthog.mcp.session_token.read_mcp_session_header(headers: Any) -> Opti
 function posthog.mcp.tools.get_more_tools_result() -> Dict[str, Any]
 function posthog.new_context(fresh: bool = False, capture_exceptions: Optional[bool] = None, client: Optional[Client] = None)
 function posthog.request.batch_post(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: float = 15, path: str = EVENTS_ENDPOINT, **kwargs) -> requests.Response
+function posthog.request.determine_app_host(host: Optional[str]) -> str
 function posthog.request.determine_server_host(host: Optional[str]) -> str
 function posthog.request.disable_connection_reuse() -> None
 function posthog.request.enable_keep_alive() -> None
@@ -1793,6 +1831,12 @@ method posthog.contexts.ContextScope.set_code_variables_mask_url_credentials(ena
 method posthog.contexts.ContextScope.set_device_id(device_id: str)
 method posthog.contexts.ContextScope.set_distinct_id(distinct_id: str)
 method posthog.contexts.ContextScope.set_session_id(session_id: str)
+method posthog.emails.AsyncEmails.aclose() -> None
+method posthog.emails.AsyncEmails.get(message_id: Union[str, UUID]) -> EmailStatus
+method posthog.emails.AsyncEmails.send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
+method posthog.emails.Emails.close() -> None
+method posthog.emails.Emails.get(message_id: Union[str, UUID]) -> EmailStatus
+method posthog.emails.Emails.send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
 method posthog.exception_capture.ExceptionCapture.capture_exception(exception, metadata=None)
 method posthog.exception_capture.ExceptionCapture.close()
 method posthog.exception_capture.ExceptionCapture.exception_handler(exc_type, exc_value, exc_traceback)
@@ -1927,6 +1971,7 @@ module posthog.capture_v1
 module posthog.client
 module posthog.consumer
 module posthog.contexts
+module posthog.emails
 module posthog.exception_capture
 module posthog.exception_utils
 module posthog.feature_flag_evaluations
diff --git a/typings/requests/__init__.pyi b/typings/requests/__init__.pyi
index 9e92acd35..1c545b680 100644
--- a/typings/requests/__init__.pyi
+++ b/typings/requests/__init__.pyi
@@ -1,6 +1,7 @@
 from typing import Any
 
 from . import adapters as adapters, auth as auth, exceptions as exceptions
+from .auth import AuthBase as _AuthBase
 
 class PreparedRequest:
     headers: dict[str, str]
@@ -27,6 +28,7 @@ class Session:
         params: dict[str, str | int] | None = ...,
         timeout: float | None = ...,
         allow_redirects: bool = ...,
+        auth: _AuthBase | None = ...,
     ) -> Response: ...
     def post(
         self,

From 139161e95fc7328148a54e442f3792a3a6038da0 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 30 Oct 2026 10:07:35 +0000
Subject: [PATCH 146/245] chore: Release v7.81.0 [skip ci]

---
 .sampo/changesets/transactional-emails.md | 5 -----
 openfeature-provider/CHANGELOG.md         | 6 ++++++
 openfeature-provider/pyproject.toml       | 2 +-
 posthog/CHANGELOG.md                      | 6 ++++++
 posthog/version.py                        | 2 +-
 pyproject.toml                            | 2 +-
 uv.lock                                   | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/transactional-emails.md

diff --git a/.sampo/changesets/transactional-emails.md b/.sampo/changesets/transactional-emails.md
deleted file mode 100644
index 21c9e6c76..000000000
--- a/.sampo/changesets/transactional-emails.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Send transactional email from PostHog email templates with `client.emails.send()` on `Posthog` and `AsyncPosthog`, or with `Emails` and `AsyncEmails` from `posthog.emails` in a process that only sends email. A send needs a project secret API key, goes to the app host, sends an idempotency key, and retries network errors, rate limits and an unavailable service with the same key. Set `app_host`, `email_request_timeout_seconds` and `email_request_max_retries` on the client to configure sends, or `max_retries` on one send. Errors raise `EmailError` with PostHog's error `code` and a category `name`. Read what happened to a sent email with `client.emails.get(message_id)`, which returns an `EmailStatus` with `status`, `created_at`, `status_at` and `reason` for 30 days after the send.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index ee6d3fcd9..fcd84c0e2 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.135 — 2026-10-30
+
+### Patch changes
+
+- Updated dependencies: posthog@7.81.0
+
 ## 0.1.134 — 2026-10-29
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index a0c4e0a79..e9f873035 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.134"
+version = "0.1.135"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 7a8453a87..437788c82 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.81.0 — 2026-10-30
+
+### Minor changes
+
+- [01e91db](https://github.com/posthog/posthog-python/commit/01e91db94185969f636d501a58a21eb9f2c3721e) Send transactional email from PostHog email templates with `client.emails.send()` on `Posthog` and `AsyncPosthog`, or with `Emails` and `AsyncEmails` from `posthog.emails` in a process that only sends email. A send needs a project secret API key, goes to the app host, sends an idempotency key, and retries network errors, rate limits and an unavailable service with the same key. Set `app_host`, `email_request_timeout_seconds` and `email_request_max_retries` on the client to configure sends, or `max_retries` on one send. Errors raise `EmailError` with PostHog's error `code` and a category `name`. Read what happened to a sent email with `client.emails.get(message_id)`, which returns an `EmailStatus` with `status`, `created_at`, `status_at` and `reason` for 30 days after the send. — Thanks @mayteio for your first contribution 🎉!
+
 ## 7.80.3 — 2026-10-29
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 0fec337ce..0d97de811 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.80.3"
+VERSION = "7.81.0"
diff --git a/pyproject.toml b/pyproject.toml
index 7ea627f64..ce32cf80d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.80.3"
+version = "7.81.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index e94d48c26..6c4966122 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.134"
+version = "0.1.135"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.80.3"
+version = "7.81.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From af8e1aa3f000a89091fe43fe7b639449671e1529 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 30 Oct 2026 10:07:40 +0000
Subject: [PATCH 147/245] Update generated references

---
 .../posthog-python-references-7.81.0.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |   20 +-
 2 files changed, 3585 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.81.0.json

diff --git a/references/posthog-python-references-7.81.0.json b/references/posthog-python-references-7.81.0.json
new file mode 100644
index 000000000..7c2dd117a
--- /dev/null
+++ b/references/posthog-python-references-7.81.0.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.81.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 8ee9a06c2..7c2dd117a 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.80.3",
+    "version": "7.81.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -660,6 +660,24 @@
               "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
               "isOptional": true,
               "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
             }
           ],
           "showDocs": true,

From be77b83462a690c8c303f5676a28207a9c17f68a Mon Sep 17 00:00:00 2001
From: Jae Bird <jaeminbird@gmail.com>
Date: Fri, 30 Oct 2026 09:19:59 -0400
Subject: [PATCH 148/245] fix(ai): keep the choices of an n>1 OpenAI chat
 stream apart (#1152)

Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .sampo/changesets/openai-stream-n-choices.md |  5 ++
 posthog/ai/openai/_streaming.py              | 78 +++++++++++++++-----
 posthog/ai/openai/openai.py                  |  4 +-
 posthog/ai/openai/openai_async.py            |  4 +-
 posthog/test/ai/openai/test_openai.py        | 53 +++++++++++++
 5 files changed, 121 insertions(+), 23 deletions(-)
 create mode 100644 .sampo/changesets/openai-stream-n-choices.md

diff --git a/.sampo/changesets/openai-stream-n-choices.md b/.sampo/changesets/openai-stream-n-choices.md
new file mode 100644
index 000000000..d2184d132
--- /dev/null
+++ b/.sampo/changesets/openai-stream-n-choices.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Keep the choices of a streamed OpenAI chat completion with `n > 1` apart in `$ai_output_choices`, as a non-streamed one already does. Their text and tool calls were interleaved into one choice.
diff --git a/posthog/ai/openai/_streaming.py b/posthog/ai/openai/_streaming.py
index cc6baf13d..3a7d059b4 100644
--- a/posthog/ai/openai/_streaming.py
+++ b/posthog/ai/openai/_streaming.py
@@ -3,13 +3,14 @@
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Union
 
-from ..types import StreamingEventData, TokenUsage
+from ..types import FormattedMessage, StreamingEventData, TokenUsage
 from ..utils import merge_usage_stats, _responses_stop_reason
 from .openai_converter import (
     accumulate_openai_tool_calls,
     extract_openai_content_from_chunk,
     extract_openai_tool_calls_from_chunk,
     extract_openai_usage_from_chunk,
+    format_openai_streaming_output,
 )
 
 
@@ -46,13 +47,26 @@ def process_chunk(self, chunk: Any) -> None:
                 self.stop_reason = stop_reason
 
 
+@dataclass
+class _ChoiceStream:
+    """One choice's view of a chunk, so the per-chunk helpers read that choice."""
+
+    choices: List[Any]
+
+
 @dataclass
 class _ChatCompletionsStreamState:
-    """Accumulates state specific to a Chat Completions stream."""
+    """Accumulates state specific to a Chat Completions stream.
+
+    With ``n > 1`` each chunk carries the delta of one choice, named by its
+    ``index``, so content and tool calls are kept per choice.
+    """
 
     usage_stats: TokenUsage = field(default_factory=lambda: TokenUsage())
-    output: List[Any] = field(default_factory=list)
-    _tool_calls: Dict[Union[int, str], Dict[str, Any]] = field(default_factory=dict)
+    _outputs: Dict[int, List[Any]] = field(default_factory=dict)
+    _tool_calls: Dict[int, Dict[Union[int, str], Dict[str, Any]]] = field(
+        default_factory=dict
+    )
     model: Optional[str] = None
     stop_reason: Optional[str] = None
     service_tier: Optional[str] = None
@@ -67,23 +81,53 @@ def process_chunk(self, chunk: Any) -> None:
         if chunk_usage:
             merge_usage_stats(self.usage_stats, chunk_usage)
 
-        content = extract_openai_content_from_chunk(chunk, "chat")
-        if content is not None:
-            self.output.append(content)
-
-        chunk_tool_calls = extract_openai_tool_calls_from_chunk(chunk)
-        if chunk_tool_calls:
-            accumulate_openai_tool_calls(self._tool_calls, chunk_tool_calls)
-
-        choices = getattr(chunk, "choices", None)
-        if choices:
-            finish_reason = getattr(choices[0], "finish_reason", None)
-            if finish_reason is not None:
+        for choice in getattr(chunk, "choices", None) or []:
+            index = getattr(choice, "index", None)
+            if not isinstance(index, int):
+                index = 0
+            view = _ChoiceStream([choice])
+
+            content = extract_openai_content_from_chunk(view, "chat")
+            if content is not None:
+                self._outputs.setdefault(index, []).append(content)
+
+            chunk_tool_calls = extract_openai_tool_calls_from_chunk(view)
+            if chunk_tool_calls:
+                accumulate_openai_tool_calls(
+                    self._tool_calls.setdefault(index, {}), chunk_tool_calls
+                )
+
+            # Like a non-streamed completion, the stop reason is the first choice's.
+            finish_reason = getattr(choice, "finish_reason", None)
+            if finish_reason is not None and index == 0:
                 self.stop_reason = finish_reason
 
     @property
     def tool_calls(self) -> Optional[List[Dict[str, Any]]]:
-        return list(self._tool_calls.values()) if self._tool_calls else None
+        calls = [
+            call
+            for index in sorted(self._tool_calls)
+            for call in self._tool_calls[index].values()
+        ]
+        return calls or None
+
+    def _indexes(self) -> List[int]:
+        return sorted(set(self._outputs) | set(self._tool_calls))
+
+    def formatted_output(self) -> List[FormattedMessage]:
+        """One assistant message with each choice's content in index order, the
+        shape a non-streamed completion is captured with."""
+        content: List[Any] = []
+        for index in self._indexes():
+            tool_calls = self._tool_calls.get(index)
+            content.extend(
+                format_openai_streaming_output(
+                    self._outputs.get(index, []),
+                    "chat",
+                    list(tool_calls.values()) if tool_calls else None,
+                )[0]["content"]
+            )
+        return [{"role": "assistant", "content": content}]
 
 
 def _build_streaming_event_data(
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index 1bdcdeb6f..998e3fd15 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -439,9 +439,7 @@ def _capture_streaming_event(
             base_url=self._client.base_url,
             kwargs=kwargs,
             formatted_input=_format_openai_streaming_input(kwargs, "chat"),
-            formatted_output=_format_openai_streaming_output(
-                state.output, "chat", state.tool_calls
-            ),
+            formatted_output=state.formatted_output(),
             usage_stats=state.usage_stats,
             latency=latency,
             distinct_id=posthog_distinct_id,
diff --git a/posthog/ai/openai/openai_async.py b/posthog/ai/openai/openai_async.py
index 1282e1ddf..a37aebb6a 100644
--- a/posthog/ai/openai/openai_async.py
+++ b/posthog/ai/openai/openai_async.py
@@ -443,9 +443,7 @@ async def _capture_streaming_event(
             base_url=self._client.base_url,
             kwargs=kwargs,
             formatted_input=format_openai_streaming_input(kwargs, "chat"),
-            formatted_output=format_openai_streaming_output(
-                state.output, "chat", state.tool_calls
-            ),
+            formatted_output=state.formatted_output(),
             usage_stats=state.usage_stats,
             latency=latency,
             distinct_id=posthog_distinct_id,
diff --git a/posthog/test/ai/openai/test_openai.py b/posthog/test/ai/openai/test_openai.py
index dcbfde242..edbe3c9de 100644
--- a/posthog/test/ai/openai/test_openai.py
+++ b/posthog/test/ai/openai/test_openai.py
@@ -2028,6 +2028,59 @@ def test_streaming_chat_extracts_model_from_chunk_when_not_in_kwargs(mock_client
         assert props["$ai_model"] == "gpt-4o-stored-prompt"
 
 
+def test_streaming_chat_keeps_n_choices_apart(mock_client):
+    # With n=2 each chunk carries one choice's delta, named by its index.
+    def chunk(index, content=None, finish_reason=None):
+        return ChatCompletionChunk(
+            id="chunk",
+            model="gpt-4o-mini",
+            object="chat.completion.chunk",
+            created=1234567890,
+            choices=[
+                ChoiceChunk(
+                    index=index,
+                    delta=ChoiceDelta(content=content),
+                    finish_reason=finish_reason,
+                )
+            ],
+        )
+
+    chunks = [
+        chunk(0, "Hello"),
+        chunk(1, "Bonjour"),
+        chunk(0, " world"),
+        chunk(1, " le monde"),
+        chunk(1, finish_reason="length"),
+        chunk(0, finish_reason="stop"),
+    ]
+
+    with patch("openai.resources.chat.completions.Completions.create") as mock_create:
+        mock_create.return_value = chunks
+        client = OpenAI(api_key="test-key", posthog_client=mock_client)
+        list(
+            client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": "Hello"}],
+                n=2,
+                stream=True,
+                posthog_distinct_id="test-id",
+            )
+        )
+
+    props = mock_client.capture.call_args[1]["properties"]
+    # The same shape a non-streamed n=2 completion is captured with.
+    assert props["$ai_output_choices"] == [
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "text", "text": "Hello world"},
+                {"type": "text", "text": "Bonjour le monde"},
+            ],
+        }
+    ]
+    assert props["$ai_stop_reason"] == "stop"
+
+
 def test_streaming_chat_prefers_kwargs_model_over_chunk_model(mock_client):
     """Test that model from kwargs takes precedence over model from chunk."""
     chunks = [

From a61e64d1a40be337af3e09925d53f56c78d0baba Mon Sep 17 00:00:00 2001
From: mosafariuk <mosafariuk@gmail.com>
Date: Fri, 30 Oct 2026 13:20:16 +0000
Subject: [PATCH 149/245] fix(ai): preserve Gemini tool call IDs in captured
 generations (#1150)

Gemini returns IDs on function calls and function responses, but the
captured $ai_output_choices and $ai_input dropped them, so tool results
could not be matched to their calls. Keep the call ID on output (streaming
and non-streaming) and on input history calls, and the result's ID as
tool_use_id, matching PostHog/posthog-js#5087.

Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .sampo/changesets/gemini-tool-call-ids.md |   5 +
 posthog/ai/gemini/gemini_converter.py     |  59 +++++++----
 posthog/test/ai/gemini/test_gemini.py     | 122 ++++++++++++++++++++++
 3 files changed, 164 insertions(+), 22 deletions(-)
 create mode 100644 .sampo/changesets/gemini-tool-call-ids.md

diff --git a/.sampo/changesets/gemini-tool-call-ids.md b/.sampo/changesets/gemini-tool-call-ids.md
new file mode 100644
index 000000000..e1716fadd
--- /dev/null
+++ b/.sampo/changesets/gemini-tool-call-ids.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Preserve Gemini tool call IDs in captured generations, on output tool calls and on tool calls and results in the input history.
diff --git a/posthog/ai/gemini/gemini_converter.py b/posthog/ai/gemini/gemini_converter.py
index ae4522746..09ae82d25 100644
--- a/posthog/ai/gemini/gemini_converter.py
+++ b/posthog/ai/gemini/gemini_converter.py
@@ -40,6 +40,18 @@ def _format_media_payload(payload: Any) -> Dict[str, Any]:
     return payload
 
 
+def _function_call_block(name: Any, arguments: Any, call_id: Any) -> Dict[str, Any]:
+    block: Dict[str, Any] = {
+        "type": "function",
+        "function": {"name": name, "arguments": arguments},
+    }
+    # Only a real string ID: Gemini omits it for some calls, and mocked parts
+    # answer any attribute.
+    if isinstance(call_id, str):
+        block["id"] = call_id
+    return block
+
+
 def _format_part(part: Any) -> Optional[FormattedContentItem]:
     if isinstance(part, str):
         return {"type": "text", "text": part}
@@ -64,20 +76,26 @@ def _format_part(part: Any) -> Optional[FormattedContentItem]:
     # shape leaves them unrenderable and invisible to evals.
     if "function_call" in plain:
         call = to_plain(plain["function_call"]) or {}
-        return {
+        block: Dict[str, Any] = {
             "type": "function",
             "function": {
                 "name": call.get("name"),
                 "arguments": call.get("args"),
             },
         }
+        if isinstance(call.get("id"), str):
+            block["id"] = call["id"]
+        return block
     if "function_response" in plain:
         response = to_plain(plain["function_response"]) or {}
-        return {
+        response_block: Dict[str, Any] = {
             "type": "function",
             "tool_name": response.get("name") or "",
             "content": response.get("response"),
         }
+        if isinstance(response.get("id"), str):
+            response_block["tool_use_id"] = response["id"]
+        return response_block
     if not plain:
         return None
     key = next(iter(plain))
@@ -269,13 +287,11 @@ def format_gemini_response(response: Any) -> List[FormattedMessage]:
                         if hasattr(part, "function_call") and part.function_call:
                             function_call = part.function_call
                             content.append(
-                                {
-                                    "type": "function",
-                                    "function": {
-                                        "name": function_call.name,
-                                        "arguments": function_call.args,
-                                    },
-                                }
+                                _function_call_block(
+                                    function_call.name,
+                                    function_call.args,
+                                    getattr(function_call, "id", None),
+                                )
                             )
                             continue
 
@@ -622,13 +638,11 @@ def extract_gemini_content_from_chunk(
                         if hasattr(part, "function_call") and part.function_call:
                             function_call = part.function_call
                             blocks.append(
-                                {
-                                    "type": "function",
-                                    "function": {
-                                        "name": function_call.name,
-                                        "arguments": function_call.args,
-                                    },
-                                }
+                                _function_call_block(
+                                    function_call.name,
+                                    function_call.args,
+                                    getattr(function_call, "id", None),
+                                )
                             )
                             continue
 
@@ -689,12 +703,13 @@ def format_gemini_streaming_output(
                         text_parts = []
 
                     # Add the function call
-                    content.append(
-                        {
-                            "type": "function",
-                            "function": item.get("function", {}),
-                        }
-                    )
+                    function_block: Dict[str, Any] = {
+                        "type": "function",
+                        "function": item.get("function", {}),
+                    }
+                    if isinstance(item.get("id"), str):
+                        function_block["id"] = item["id"]
+                    content.append(function_block)
                 else:
                     if text_parts:
                         content.append(
diff --git a/posthog/test/ai/gemini/test_gemini.py b/posthog/test/ai/gemini/test_gemini.py
index f2a801e68..b616dcd89 100644
--- a/posthog/test/ai/gemini/test_gemini.py
+++ b/posthog/test/ai/gemini/test_gemini.py
@@ -797,6 +797,128 @@ def test_function_calls_only_no_content(
     assert props["$ai_http_status"] == 200
 
 
+def _function_call_response(call_id):
+    from google.genai import types
+
+    return types.GenerateContentResponse(
+        candidates=[
+            types.Candidate(
+                content=types.Content(
+                    role="model",
+                    parts=[
+                        types.Part(
+                            function_call=types.FunctionCall(
+                                id=call_id, name="describe_shape", args={"sides": 3}
+                            )
+                        )
+                    ],
+                ),
+                finish_reason="STOP",
+            )
+        ],
+        usage_metadata=types.GenerateContentResponseUsageMetadata(
+            prompt_token_count=10, candidates_token_count=5, total_token_count=15
+        ),
+    )
+
+
+@pytest.mark.parametrize("stream", [False, True])
+@pytest.mark.parametrize("call_id", ["call_649034", None])
+def test_function_call_ids_in_output_choices(
+    mock_client, mock_google_genai_client, stream, call_id
+):
+    """Gemini's function-call ID is kept in $ai_output_choices when present."""
+    response = _function_call_response(call_id)
+    client = Client(api_key="test-key", posthog_client=mock_client)
+
+    if stream:
+        mock_google_genai_client.models.generate_content_stream.return_value = iter(
+            [response]
+        )
+        list(
+            client.models.generate_content_stream(
+                model="gemini-2.5-flash",
+                contents="Describe a triangle",
+                posthog_distinct_id="test-id",
+            )
+        )
+    else:
+        mock_google_genai_client.models.generate_content.return_value = response
+        client.models.generate_content(
+            model="gemini-2.5-flash",
+            contents="Describe a triangle",
+            posthog_distinct_id="test-id",
+        )
+
+    expected_call = {
+        "type": "function",
+        "function": {"name": "describe_shape", "arguments": {"sides": 3}},
+    }
+    if call_id is not None:
+        expected_call["id"] = call_id
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_output_choices"] == [
+        {"role": "assistant", "content": [expected_call]}
+    ]
+
+
+def test_function_call_ids_in_input_history(
+    mock_client, mock_google_genai_client, mock_gemini_response
+):
+    """IDs on function_call and function_response parts in the input history are
+    kept, so a tool result can be matched to its call."""
+    from google.genai import types
+
+    mock_google_genai_client.models.generate_content.return_value = mock_gemini_response
+    client = Client(api_key="test-key", posthog_client=mock_client)
+    client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[
+            types.Content(role="user", parts=[types.Part(text="Describe a triangle")]),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part(
+                        function_call=types.FunctionCall(
+                            id="call_649034", name="describe_shape", args={"sides": 3}
+                        )
+                    )
+                ],
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part(
+                        function_response=types.FunctionResponse(
+                            id="call_649034",
+                            name="describe_shape",
+                            response={"shape": "triangle"},
+                        )
+                    )
+                ],
+            ),
+        ],
+        posthog_distinct_id="test-id",
+    )
+
+    props = mock_client.capture.call_args[1]["properties"]
+    call_block, result_block = [
+        block
+        for message in props["$ai_input"]
+        for block in (
+            message["content"] if isinstance(message["content"], list) else []
+        )
+        if block.get("type") == "function"
+    ]
+    assert call_block["id"] == "call_649034"
+    assert call_block["function"] == {
+        "name": "describe_shape",
+        "arguments": {"sides": 3},
+    }
+    assert result_block["tool_use_id"] == "call_649034"
+    assert result_block["tool_name"] == "describe_shape"
+
+
 def test_cache_and_reasoning_tokens(mock_client, mock_google_genai_client):
     """Test that cache and reasoning tokens are properly extracted"""
     # Create a mock response with cache and reasoning tokens

From f23efe9d3e0dfe68a7136f80a48e6420ada38e41 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 30 Oct 2026 13:56:29 +0000
Subject: [PATCH 150/245] chore: Release v7.81.1 [skip ci]

---
 .sampo/changesets/gemini-tool-call-ids.md    | 5 -----
 .sampo/changesets/openai-stream-n-choices.md | 5 -----
 openfeature-provider/CHANGELOG.md            | 6 ++++++
 openfeature-provider/pyproject.toml          | 2 +-
 posthog/CHANGELOG.md                         | 7 +++++++
 posthog/version.py                           | 2 +-
 pyproject.toml                               | 2 +-
 uv.lock                                      | 4 ++--
 8 files changed, 18 insertions(+), 15 deletions(-)
 delete mode 100644 .sampo/changesets/gemini-tool-call-ids.md
 delete mode 100644 .sampo/changesets/openai-stream-n-choices.md

diff --git a/.sampo/changesets/gemini-tool-call-ids.md b/.sampo/changesets/gemini-tool-call-ids.md
deleted file mode 100644
index e1716fadd..000000000
--- a/.sampo/changesets/gemini-tool-call-ids.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Preserve Gemini tool call IDs in captured generations, on output tool calls and on tool calls and results in the input history.
diff --git a/.sampo/changesets/openai-stream-n-choices.md b/.sampo/changesets/openai-stream-n-choices.md
deleted file mode 100644
index d2184d132..000000000
--- a/.sampo/changesets/openai-stream-n-choices.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Keep the choices of a streamed OpenAI chat completion with `n > 1` apart in `$ai_output_choices`, as a non-streamed one already does. Their text and tool calls were interleaved into one choice.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index fcd84c0e2..6ad874b34 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.136 — 2026-10-30
+
+### Patch changes
+
+- Updated dependencies: posthog@7.81.1
+
 ## 0.1.135 — 2026-10-30
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index e9f873035..4c9b351aa 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.135"
+version = "0.1.136"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 437788c82..38a8a95cb 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,12 @@
 # posthog
 
+## 7.81.1 — 2026-10-30
+
+### Patch changes
+
+- [be77b83](https://github.com/posthog/posthog-python/commit/be77b83462a690c8c303f5676a28207a9c17f68a) Keep the choices of a streamed OpenAI chat completion with `n > 1` apart in `$ai_output_choices`, as a non-streamed one already does. Their text and tool calls were interleaved into one choice. — Thanks @jaeminbird for your first contribution 🎉!
+- [a61e64d](https://github.com/posthog/posthog-python/commit/a61e64d1a40be337af3e09925d53f56c78d0baba) Preserve Gemini tool call IDs in captured generations, on output tool calls and on tool calls and results in the input history. — Thanks @mosafariuk!
+
 ## 7.81.0 — 2026-10-30
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 0d97de811..e1d5d3575 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.81.0"
+VERSION = "7.81.1"
diff --git a/pyproject.toml b/pyproject.toml
index ce32cf80d..85c3d93bd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.81.0"
+version = "7.81.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 6c4966122..d78a0692d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.135"
+version = "0.1.136"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.81.0"
+version = "7.81.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From dca22075ced7f4beaca798a8dd155169eec50b4d Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 30 Oct 2026 13:56:34 +0000
Subject: [PATCH 151/245] Update generated references

---
 .../posthog-python-references-7.81.1.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.81.1.json

diff --git a/references/posthog-python-references-7.81.1.json b/references/posthog-python-references-7.81.1.json
new file mode 100644
index 000000000..2bbfeaef9
--- /dev/null
+++ b/references/posthog-python-references-7.81.1.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.81.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 7c2dd117a..2bbfeaef9 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.81.0",
+    "version": "7.81.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b4c2e472145de495d0d7807d9c22618de2e0706f Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Mon, 2 Nov 2026 04:51:23 -0500
Subject: [PATCH 152/245] docs(mcp): clarify unsigned session token trust
 (#1151)

---
 posthog/mcp/session_token.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/posthog/mcp/session_token.py b/posthog/mcp/session_token.py
index 228c0a593..ac2b38593 100644
--- a/posthog/mcp/session_token.py
+++ b/posthog/mcp/session_token.py
@@ -6,8 +6,9 @@
 So at ``initialize`` we mint that header as a token carrying the session id and
 client identity -- any pod can read them back from the header alone.
 
-The token is unsigned: it holds only what the client already self-reports. It is
-wire-compatible with the TypeScript SDK (same short keys ``sid``/``cn``/``cv``/``pv``),
+The token is unsigned, so clients can change its contents. Use decoded values
+for analytics, not authentication or authorization. It is wire-compatible with
+the TypeScript SDK (same short keys ``sid``/``cn``/``cv``/``pv``),
 so a token minted by one SDK decodes in the other.
 """
 

From f20066e7f2826dab701a8d73fbfd5780c4ccd49a Mon Sep 17 00:00:00 2001
From: Harley Alexander <43975092+mayteio@users.noreply.github.com>
Date: Mon, 2 Nov 2026 11:48:30 +0000
Subject: [PATCH 153/245] feat: send a flat body from emails.send (#1155)

emails.send now posts template_id and distinct_id at the top level of the request body, for the sync and async clients. The server accepts both shapes, so this changes only the wire format.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: e72a2c10-f145-4f7c-8754-a4fcc06a18be
---
 .sampo/changesets/emails-flat-send-body.md | 5 +++++
 posthog/emails.py                          | 4 ++--
 posthog/test/test_emails.py                | 6 +++---
 3 files changed, 10 insertions(+), 5 deletions(-)
 create mode 100644 .sampo/changesets/emails-flat-send-body.md

diff --git a/.sampo/changesets/emails-flat-send-body.md b/.sampo/changesets/emails-flat-send-body.md
new file mode 100644
index 000000000..bf6923081
--- /dev/null
+++ b/.sampo/changesets/emails-flat-send-body.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+`emails.send()` now sends the template ID and distinct ID as top-level fields in the request body.
diff --git a/posthog/emails.py b/posthog/emails.py
index 72b1ca3ef..c5bb6cec8 100644
--- a/posthog/emails.py
+++ b/posthog/emails.py
@@ -242,12 +242,12 @@ def _prepare_send(
         raise ValueError("max_retries must be a nonnegative integer.")
 
     payload: dict[str, Any] = {
-        "template": {"id": str(template_uuid)},
+        "template_id": str(template_uuid),
         "to": to,
         "message_data": clean(dict(template_data or {})),
     }
     if distinct_id is not None:
-        payload["identifiers"] = {"distinct_id": distinct_id}
+        payload["distinct_id"] = distinct_id
     return _PreparedSend(
         path=_SEND_PATH,
         body=json.dumps(payload, cls=DatetimeSerializer).encode("utf-8"),
diff --git a/posthog/test/test_emails.py b/posthog/test/test_emails.py
index 0d2099a86..c0aeac2e8 100644
--- a/posthog/test/test_emails.py
+++ b/posthog/test/test_emails.py
@@ -99,7 +99,7 @@ def no_sleep():
         (
             "with_distinct_id",
             {"distinct_id": "user_123"},
-            {"identifiers": {"distinct_id": "user_123"}},
+            {"distinct_id": "user_123"},
         ),
         ("without_distinct_id", {}, {}),
     ]
@@ -125,7 +125,7 @@ def test_send_posts_the_template_to_the_app_host(_name, overrides, extra_body):
     assert request.headers["Idempotency-Key"] == "welcome:user_123"
     assert request.headers["User-Agent"] == f"posthog-python/{VERSION}"
     assert json.loads(request.body) == {
-        "template": {"id": TEMPLATE_ID},
+        "template_id": TEMPLATE_ID,
         "to": "user@example.com",
         "message_data": {"total": 19.5, "expires_at": "2026-11-20T00:00:00+00:00"},
         **extra_body,
@@ -423,7 +423,7 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert seen[0].extensions["timeout"] == dict.fromkeys(
         ["connect", "read", "write", "pool"], 3
     )
-    assert json.loads(seen[0].content)["identifiers"] == {"distinct_id": "user_123"}
+    assert json.loads(seen[0].content)["distinct_id"] == "user_123"
 
 
 @pytest.mark.asyncio

From 0aec2d995e8b29ef3766e04e617b5faceb1ca86f Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 12:09:57 +0000
Subject: [PATCH 154/245] chore: Release v7.81.2 [skip ci]

---
 .sampo/changesets/emails-flat-send-body.md | 5 -----
 openfeature-provider/CHANGELOG.md          | 6 ++++++
 openfeature-provider/pyproject.toml        | 2 +-
 posthog/CHANGELOG.md                       | 6 ++++++
 posthog/version.py                         | 2 +-
 pyproject.toml                             | 2 +-
 uv.lock                                    | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/emails-flat-send-body.md

diff --git a/.sampo/changesets/emails-flat-send-body.md b/.sampo/changesets/emails-flat-send-body.md
deleted file mode 100644
index bf6923081..000000000
--- a/.sampo/changesets/emails-flat-send-body.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-`emails.send()` now sends the template ID and distinct ID as top-level fields in the request body.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 6ad874b34..bcf1a6d8a 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.137 — 2026-11-02
+
+### Patch changes
+
+- Updated dependencies: posthog@7.81.2
+
 ## 0.1.136 — 2026-10-30
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 4c9b351aa..5134031e3 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.136"
+version = "0.1.137"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 38a8a95cb..6a7aa5d85 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.81.2 — 2026-11-02
+
+### Patch changes
+
+- [f20066e](https://github.com/posthog/posthog-python/commit/f20066e7f2826dab701a8d73fbfd5780c4ccd49a) `emails.send()` now sends the template ID and distinct ID as top-level fields in the request body. — Thanks @mayteio!
+
 ## 7.81.1 — 2026-10-30
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index e1d5d3575..e1c8871d3 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.81.1"
+VERSION = "7.81.2"
diff --git a/pyproject.toml b/pyproject.toml
index 85c3d93bd..f8e423654 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.81.1"
+version = "7.81.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index d78a0692d..5294972b2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.136"
+version = "0.1.137"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.81.1"
+version = "7.81.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 14b4d33ca91d3e60acc05f6424727d7a4c051029 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 12:10:02 +0000
Subject: [PATCH 155/245] Update generated references

---
 .../posthog-python-references-7.81.2.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.81.2.json

diff --git a/references/posthog-python-references-7.81.2.json b/references/posthog-python-references-7.81.2.json
new file mode 100644
index 000000000..15ba9a742
--- /dev/null
+++ b/references/posthog-python-references-7.81.2.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.81.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 2bbfeaef9..15ba9a742 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.81.1",
+    "version": "7.81.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b10c38ac3928f3b1cef743dab234e17720c81f08 Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Mon, 2 Nov 2026 15:30:36 +0100
Subject: [PATCH 156/245] feat: add a per-read send_feature_flag_events option
 to snapshot reads (#1148)

---
 .../changesets/snapshot-flag-event-option.md  |   5 +
 posthog/feature_flag_evaluations.py           |  29 ++++-
 posthog/test/test_evaluate_flags.py           | 120 ++++++++++++++++++
 references/public_api_snapshot.txt            |   4 +-
 4 files changed, 151 insertions(+), 7 deletions(-)
 create mode 100644 .sampo/changesets/snapshot-flag-event-option.md

diff --git a/.sampo/changesets/snapshot-flag-event-option.md b/.sampo/changesets/snapshot-flag-event-option.md
new file mode 100644
index 000000000..9668d4318
--- /dev/null
+++ b/.sampo/changesets/snapshot-flag-event-option.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add a per-read `send_feature_flag_events` option to `FeatureFlagEvaluations.is_enabled()` and `get_flag()`. Pass `send_feature_flag_events=False` to read a flag from an `evaluate_flags()` snapshot without sending `$feature_flag_called`. The read leaves the dedupe cache alone, so a later read that sends events still reports the flag, and the key still counts as accessed for `only_accessed()`. The option defaults to `True`, as on `get_feature_flag()`.
diff --git a/posthog/feature_flag_evaluations.py b/posthog/feature_flag_evaluations.py
index 13d8c7df9..ef4859b46 100644
--- a/posthog/feature_flag_evaluations.py
+++ b/posthog/feature_flag_evaluations.py
@@ -95,7 +95,13 @@ def __init__(
             unresolved_flags or {}
         )
 
-    def is_enabled(self, key: str, default_value: bool = False) -> bool:
+    def is_enabled(
+        self,
+        key: str,
+        default_value: bool = False,
+        *,
+        send_feature_flag_events: bool = True,
+    ) -> bool:
         """Return whether the flag is enabled. Fires ``$feature_flag_called`` on the
         first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
 
@@ -105,23 +111,31 @@ def is_enabled(self, key: str, default_value: bool = False) -> bool:
                 the key was not part of the evaluated set, or the evaluation itself
                 came back empty (failed ``/flags`` request, quota limit, or no
                 resolvable ``distinct_id``). Defaults to ``False``.
+            send_feature_flag_events: Whether this read sends ``$feature_flag_called``.
+                When ``False``, no event is sent and the dedupe cache is left alone,
+                but the key still counts as accessed for :meth:`only_accessed`.
 
         A flag that has a value always wins over ``default_value``, including a
         disabled flag, which returns ``False`` even when ``default_value=True``.
         """
         flag = self._flags.get(key)
-        self._record_access(key)
+        self._record_access(key, send_feature_flag_events)
         return bool(flag.enabled) if flag else default_value
 
-    def get_flag(self, key: str) -> Optional[FlagValue]:
+    def get_flag(
+        self, key: str, *, send_feature_flag_events: bool = True
+    ) -> Optional[FlagValue]:
         """Return the flag value. Fires ``$feature_flag_called`` on first access.
 
         Returns the variant string for multivariate flags, ``True`` for enabled flags
         without a variant, ``False`` for disabled flags, and ``None`` for flags that
         were not returned by the evaluation.
+
+        Pass ``send_feature_flag_events=False`` to skip the event for this read, as
+        with :meth:`is_enabled`.
         """
         flag = self._flags.get(key)
-        self._record_access(key)
+        self._record_access(key, send_feature_flag_events)
         if not flag:
             return None
         if not flag.enabled:
@@ -236,9 +250,14 @@ def _clone_with(
             accessed=set(self._accessed),
         )
 
-    def _record_access(self, key: str) -> None:
+    def _record_access(self, key: str, send_feature_flag_events: bool) -> None:
         self._accessed.add(key)
 
+        # A suppressed read skips the dedupe cache too, so a later read that sends
+        # events still reports this flag.
+        if not send_feature_flag_events:
+            return
+
         # Empty snapshots (no resolvable distinct_id) are returned by ``evaluate_flags()``
         # as a safety fallback. Firing $feature_flag_called for them would emit events
         # with an empty distinct_id, polluting analytics — short-circuit here.
diff --git a/posthog/test/test_evaluate_flags.py b/posthog/test/test_evaluate_flags.py
index 25ca18e51..dec98a762 100644
--- a/posthog/test/test_evaluate_flags.py
+++ b/posthog/test/test_evaluate_flags.py
@@ -1301,6 +1301,126 @@ def test_filtered_snapshots_do_not_back_propagate_access(self, patch_flags):
         self.assertEqual(flags.only_accessed().keys, ["boolean-flag"])
 
 
+class TestEvaluateFlagsPerReadEventOption(unittest.TestCase):
+    """Per-read ``send_feature_flag_events`` on snapshot reads (sdk-specs
+    evaluate-flags "Snapshot feature flag event control")."""
+
+    def setUp(self):
+        self.client = Client(FAKE_TEST_API_KEY)
+
+    def tearDown(self):
+        self.client.shutdown()
+
+    @staticmethod
+    def _flag_called(patch_capture):
+        return [
+            (c[1]["properties"]["$feature_flag"], c[1]["properties"])
+            for c in patch_capture.call_args_list
+            if c[0] and c[0][0] == "$feature_flag_called"
+        ]
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_option_false_silences_one_read(self, patch_capture, patch_flags):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        enabled = flags.is_enabled("boolean-flag", send_feature_flag_events=False)
+        value = flags.get_flag("variant-flag")
+
+        self.assertEqual((enabled, value), (True, "variant-value"))
+        self.assertEqual(patch_flags.call_count, 1)
+        events = self._flag_called(patch_capture)
+        self.assertEqual([key for key, _ in events], ["variant-flag"])
+        self.assertEqual(events[0][1]["$feature_flag_response"], "variant-value")
+        self.assertEqual(patch_capture.call_args[1]["distinct_id"], "user-1")
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_option_true_sends_events(self, patch_capture, patch_flags):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        flags.is_enabled("boolean-flag", send_feature_flag_events=True)
+        flags.get_flag("variant-flag", send_feature_flag_events=True)
+
+        self.assertEqual(
+            [key for key, _ in self._flag_called(patch_capture)],
+            ["boolean-flag", "variant-flag"],
+        )
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_suppressed_read_leaves_dedupe_untouched(self, patch_capture, patch_flags):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        results = [
+            flags.is_enabled("boolean-flag", send_feature_flag_events=False),
+            flags.get_flag("boolean-flag"),
+            flags.is_enabled("boolean-flag"),
+        ]
+
+        self.assertEqual(results, [True, True, True])
+        self.assertEqual(patch_flags.call_count, 1)
+        events = self._flag_called(patch_capture)
+        self.assertEqual([key for key, _ in events], ["boolean-flag"])
+        self.assertIs(events[0][1]["$feature_flag_response"], True)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_suppressed_read_leaves_single_flag_getter_exposure_intact(
+        self, patch_capture, patch_flags
+    ):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        snapshot_value = flags.is_enabled(
+            "boolean-flag", send_feature_flag_events=False
+        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            getter_value = self.client.get_feature_flag("boolean-flag", "user-1")
+
+        self.assertEqual((snapshot_value, getter_value), (True, True))
+        events = self._flag_called(patch_capture)
+        self.assertEqual([key for key, _ in events], ["boolean-flag"])
+        self.assertIs(events[0][1]["$feature_flag_response"], True)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_suppressed_reads_still_count_for_only_accessed(
+        self, patch_capture, patch_flags
+    ):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        enabled = flags.is_enabled("boolean-flag", send_feature_flag_events=False)
+        value = flags.get_flag("disabled-flag", send_feature_flag_events=False)
+
+        self.assertEqual((enabled, value), (True, False))
+        self.assertEqual(
+            sorted(flags.only_accessed().keys), ["boolean-flag", "disabled-flag"]
+        )
+        self.assertEqual(patch_flags.call_count, 1)
+        self.assertEqual(self._flag_called(patch_capture), [])
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_suppressed_missing_key_reports_no_missing_flag(
+        self, patch_capture, patch_flags
+    ):
+        patch_flags.return_value = _flags_response_fixture()
+        flags = self.client.evaluate_flags("user-1")
+
+        enabled = flags.is_enabled("missing-flag", send_feature_flag_events=False)
+        value = flags.get_flag("missing-flag", send_feature_flag_events=False)
+
+        self.assertEqual((enabled, value), (False, None))
+        self.assertEqual(patch_flags.call_count, 1)
+        self.assertEqual(self._flag_called(patch_capture), [])
+
+
 class TestCaptureWithFlagsSnapshot(unittest.TestCase):
     def setUp(self):
         self.client = Client(FAKE_TEST_API_KEY)
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 3eadb81bd..db204f127 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1848,9 +1848,9 @@ method posthog.exception_utils.AnnotatedValue.substituted_because_contains_sensi
 method posthog.exception_utils.VariableSizeLimiter.add(size)
 method posthog.exception_utils.VariableSizeLimiter.can_add(size)
 method posthog.exception_utils.VariableSizeLimiter.get_remaining_space()
-method posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag(key: str) -> Optional[FlagValue]
+method posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag(key: str, *, send_feature_flag_events: bool = True) -> Optional[FlagValue]
 method posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag_payload(key: str) -> Optional[Any]
-method posthog.feature_flag_evaluations.FeatureFlagEvaluations.is_enabled(key: str, default_value: bool = False) -> bool
+method posthog.feature_flag_evaluations.FeatureFlagEvaluations.is_enabled(key: str, default_value: bool = False, *, send_feature_flag_events: bool = True) -> bool
 method posthog.feature_flag_evaluations.FeatureFlagEvaluations.only(keys: List[str]) -> FeatureFlagEvaluations
 method posthog.feature_flag_evaluations.FeatureFlagEvaluations.only_accessed() -> FeatureFlagEvaluations
 method posthog.flag_definition_cache.FlagDefinitionCacheProvider.get_flag_definitions() -> Union[Optional[FlagDefinitionCacheData], Awaitable[Optional[FlagDefinitionCacheData]]]

From e24100b413d8f1a4f14c49dbee3391c8675fb2ff Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Mon, 2 Nov 2026 15:31:12 +0100
Subject: [PATCH 157/245] fix: send flag id and version on locally evaluated
 $feature_flag_called (#1149)

Locally evaluated flags in get_feature_flag(), feature_enabled() and
get_feature_flag_result() sent $feature_flag_called without
$feature_flag_id or $feature_flag_version, because both were read only
from remote /flags metadata. Read them from the local flag definition
that produced the value. evaluate_flags() already sent the id for local
flags but dropped the definition's version; send it too.
---
 .../local-flag-called-id-version.md           |  5 +++
 posthog/client.py                             | 20 ++++++++--
 posthog/test/test_evaluate_flags.py           | 32 +++++++++++++++
 .../test_feature_flag_called_minimization.py  |  1 +
 posthog/test/test_feature_flag_result.py      |  3 ++
 posthog/test/test_feature_flags.py            | 39 +++++++++++++++++++
 6 files changed, 96 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/local-flag-called-id-version.md

diff --git a/.sampo/changesets/local-flag-called-id-version.md b/.sampo/changesets/local-flag-called-id-version.md
new file mode 100644
index 000000000..18e818423
--- /dev/null
+++ b/.sampo/changesets/local-flag-called-id-version.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Add `$feature_flag_id` and `$feature_flag_version` to `$feature_flag_called` events for locally evaluated flags in `get_feature_flag()`, `feature_enabled()` and `get_feature_flag_result()`, and `$feature_flag_version` for locally evaluated flags in `evaluate_flags()`, taken from the flag definition. Remotely evaluated flags already sent both.
diff --git a/posthog/client.py b/posthog/client.py
index 388e20b2d..3db53ea74 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -4211,12 +4211,18 @@ def _get_feature_flag_result(
             # Source the gate the same way as has_experiment above; see
             # _capture_feature_flag_called_if_needed for why.
             minimal_flag_called_events = self._minimal_flag_called_events
+            # Remotely-evaluated flags carry id and version in the response metadata;
+            # locally-evaluated flags read them from the definition that produced the value.
+            local_flag_id: Optional[int] = None
+            local_flag_version: Optional[int] = None
             if flag_was_locally_evaluated:
-                local_def = (self.feature_flags_by_key or {}).get(key)
+                local_def = snapshot["flags_by_key"].get(key)
                 if isinstance(local_def, dict):
                     has_experiment = _parse_has_experiment(
                         local_def.get("has_experiment")
                     )
+                    local_flag_id = local_def.get("id")
+                    local_flag_version = local_def.get("version")
             elif isinstance(flag_details, FeatureFlag):
                 has_experiment = _metadata_has_experiment(flag_details.metadata)
                 minimal_flag_called_events = remote_minimal_flag_called_events
@@ -4235,6 +4241,8 @@ def _get_feature_flag_result(
                 feature_flag_error,
                 has_experiment,
                 minimal_flag_called_events,
+                local_flag_id=local_flag_id,
+                local_flag_version=local_flag_version,
             )
 
         return flag_result
@@ -4524,6 +4532,8 @@ def _capture_feature_flag_called(
         feature_flag_error: Optional[str] = None,
         has_experiment: Optional[bool] = None,
         minimal_flag_called_events: bool = False,
+        local_flag_id: Optional[int] = None,
+        local_flag_version: Optional[int] = None,
     ):
         properties: dict[str, Any] = {
             "$feature_flag": key,
@@ -4548,6 +4558,10 @@ def _capture_feature_flag_called(
                     properties["$feature_flag_version"] = flag_details.metadata.version
                 if flag_details.metadata.id:
                     properties["$feature_flag_id"] = flag_details.metadata.id
+        if local_flag_version:
+            properties["$feature_flag_version"] = local_flag_version
+        if local_flag_id:
+            properties["$feature_flag_id"] = local_flag_id
         if feature_flag_error:
             properties["$feature_flag_error"] = feature_flag_error
 
@@ -4983,9 +4997,7 @@ def evaluate_flags(
                 variant=value if isinstance(value, str) else None,
                 payload=_parse_flag_payload(local_payloads.get(key)),
                 id=flag_def.get("id"),
-                # The local-evaluation flag definition does not carry a version field;
-                # only the remote ``/flags`` response does via ``metadata.version``.
-                version=None,
+                version=flag_def.get("version"),
                 reason="Evaluated locally",
                 locally_evaluated=True,
                 has_experiment=_parse_has_experiment(flag_def.get("has_experiment")),
diff --git a/posthog/test/test_evaluate_flags.py b/posthog/test/test_evaluate_flags.py
index dec98a762..d22be7719 100644
--- a/posthog/test/test_evaluate_flags.py
+++ b/posthog/test/test_evaluate_flags.py
@@ -431,6 +431,38 @@ def test_flag_called_event_carries_parsed_local_payload(
         self.assertEqual(properties["$feature_flag_payload"], {"copy": "new"})
 
 
+class TestEvaluateFlagsLocalFlagIdentity(unittest.TestCase):
+    """Locally-evaluated flags report the definition's id and version, the same
+    properties remote ``/flags`` metadata supplies."""
+
+    def setUp(self):
+        self.client = Client(FAKE_TEST_API_KEY, secret_key="test")
+        self.client.feature_flags = [
+            _always_on_flag("local-flag", id=4211, version=7),
+            _always_on_flag("unversioned-flag", id=4212),
+        ]
+
+    def tearDown(self):
+        self.client.shutdown()
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch.object(Client, "capture")
+    def test_flag_called_event_carries_definition_id_and_version(
+        self, patch_capture, patch_flags
+    ):
+        flags = self.client.evaluate_flags("user-1")
+        flags.is_enabled("local-flag")
+        flags.get_flag("unversioned-flag")
+
+        patch_flags.assert_not_called()
+        properties = _flag_called_properties(patch_capture)
+        self.assertTrue(properties["local-flag"]["locally_evaluated"])
+        self.assertEqual(properties["local-flag"]["$feature_flag_id"], 4211)
+        self.assertEqual(properties["local-flag"]["$feature_flag_version"], 7)
+        self.assertEqual(properties["unversioned-flag"]["$feature_flag_id"], 4212)
+        self.assertNotIn("$feature_flag_version", properties["unversioned-flag"])
+
+
 class TestEvaluateFlagsMissingLocalDefinition(unittest.TestCase):
     def setUp(self):
         self.client = Client(FAKE_TEST_API_KEY, secret_key="test")
diff --git a/posthog/test/test_feature_flag_called_minimization.py b/posthog/test/test_feature_flag_called_minimization.py
index 32310beca..9a23e6b17 100644
--- a/posthog/test/test_feature_flag_called_minimization.py
+++ b/posthog/test/test_feature_flag_called_minimization.py
@@ -297,6 +297,7 @@ def test_gated_non_experiment_flag_sends_exactly_the_allowlist(
             {
                 "$feature_flag",
                 "$feature_flag_response",
+                "$feature_flag_id",
                 "$feature_flag_has_experiment",
                 "locally_evaluated",
                 "$lib",
diff --git a/posthog/test/test_feature_flag_result.py b/posthog/test/test_feature_flag_result.py
index fcfdc968c..5b57ebbd4 100644
--- a/posthog/test/test_feature_flag_result.py
+++ b/posthog/test/test_feature_flag_result.py
@@ -242,6 +242,7 @@ def test_get_feature_flag_result_boolean_local_evaluation(self, patch_capture):
                 "locally_evaluated": True,
                 "$feature/person-flag": True,
                 "$feature_flag_payload": 300,
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=None,
@@ -299,6 +300,7 @@ def test_get_feature_flag_result_variant_local_evaluation(self, patch_capture):
                 "locally_evaluated": True,
                 "$feature/person-flag": "variant-1",
                 "$feature_flag_payload": {"some": "value"},
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=None,
@@ -323,6 +325,7 @@ def test_get_feature_flag_result_variant_local_evaluation(self, patch_capture):
                 "$feature_flag_response": "variant-2",
                 "locally_evaluated": True,
                 "$feature/person-flag": "variant-2",
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=None,
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index 14a1ed18e..b52ec3bfa 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -7181,6 +7181,41 @@ def test_year_parsing(self):
 
 
 class TestCaptureCalls(unittest.TestCase):
+    @parameterized.expand(
+        [
+            ("get_feature_flag", lambda c: c.get_feature_flag),
+            ("feature_enabled", lambda c: c.feature_enabled),
+            ("get_feature_flag_result", lambda c: c.get_feature_flag_result),
+        ]
+    )
+    @mock.patch.object(Client, "capture")
+    @mock.patch("posthog.client.flags")
+    def test_locally_evaluated_flag_called_event_carries_definition_id_and_version(
+        self, _name, getter, patch_flags, patch_capture
+    ):
+        client = Client(FAKE_TEST_API_KEY, secret_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 4211,
+                "version": 7,
+                "name": "Local Feature",
+                "key": "local-flag",
+                "active": True,
+                "filters": {
+                    "groups": [{"properties": [], "rollout_percentage": 100}],
+                },
+            }
+        ]
+
+        self.assertTrue(getter(client)("local-flag", "some-distinct-id"))
+
+        patch_flags.assert_not_called()
+        patch_capture.assert_called_once()
+        properties = patch_capture.call_args[1]["properties"]
+        self.assertTrue(properties["locally_evaluated"])
+        self.assertEqual(properties["$feature_flag_id"], 4211)
+        self.assertEqual(properties["$feature_flag_version"], 7)
+
     @mock.patch.object(Client, "capture")
     @mock.patch("posthog.client.flags")
     def test_capture_is_called(self, patch_flags, patch_capture):
@@ -7219,6 +7254,7 @@ def test_capture_is_called(self, patch_flags, patch_capture):
                 "$feature_flag_response": True,
                 "locally_evaluated": True,
                 "$feature/complex-flag": True,
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=None,
@@ -7253,6 +7289,7 @@ def test_capture_is_called(self, patch_flags, patch_capture):
                 "$feature_flag_response": True,
                 "locally_evaluated": True,
                 "$feature/complex-flag": True,
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=None,
@@ -7591,6 +7628,7 @@ def test_disable_geoip_get_flag_capture_call(self, patch_flags, patch_capture):
                 "$feature_flag_response": True,
                 "locally_evaluated": True,
                 "$feature/complex-flag": True,
+                "$feature_flag_id": 1,
             },
             groups={},
             disable_geoip=False,
@@ -7713,6 +7751,7 @@ def test_capture_multiple_users_doesnt_out_of_memory(
                         "$feature_flag_response": True,
                         "locally_evaluated": True,
                         "$feature/complex-flag": True,
+                        "$feature_flag_id": 1,
                     },
                     groups={},
                     disable_geoip=None,

From b6f8eafa5ed9ab1d31bfbf4e477e24a664b2b91e Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 14:35:41 +0000
Subject: [PATCH 158/245] chore: Release v7.82.0 [skip ci]

---
 .sampo/changesets/local-flag-called-id-version.md |  5 -----
 .sampo/changesets/snapshot-flag-event-option.md   |  5 -----
 openfeature-provider/CHANGELOG.md                 |  6 ++++++
 openfeature-provider/pyproject.toml               |  2 +-
 posthog/CHANGELOG.md                              | 10 ++++++++++
 posthog/version.py                                |  2 +-
 pyproject.toml                                    |  2 +-
 uv.lock                                           |  4 ++--
 8 files changed, 21 insertions(+), 15 deletions(-)
 delete mode 100644 .sampo/changesets/local-flag-called-id-version.md
 delete mode 100644 .sampo/changesets/snapshot-flag-event-option.md

diff --git a/.sampo/changesets/local-flag-called-id-version.md b/.sampo/changesets/local-flag-called-id-version.md
deleted file mode 100644
index 18e818423..000000000
--- a/.sampo/changesets/local-flag-called-id-version.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Add `$feature_flag_id` and `$feature_flag_version` to `$feature_flag_called` events for locally evaluated flags in `get_feature_flag()`, `feature_enabled()` and `get_feature_flag_result()`, and `$feature_flag_version` for locally evaluated flags in `evaluate_flags()`, taken from the flag definition. Remotely evaluated flags already sent both.
diff --git a/.sampo/changesets/snapshot-flag-event-option.md b/.sampo/changesets/snapshot-flag-event-option.md
deleted file mode 100644
index 9668d4318..000000000
--- a/.sampo/changesets/snapshot-flag-event-option.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Add a per-read `send_feature_flag_events` option to `FeatureFlagEvaluations.is_enabled()` and `get_flag()`. Pass `send_feature_flag_events=False` to read a flag from an `evaluate_flags()` snapshot without sending `$feature_flag_called`. The read leaves the dedupe cache alone, so a later read that sends events still reports the flag, and the key still counts as accessed for `only_accessed()`. The option defaults to `True`, as on `get_feature_flag()`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index bcf1a6d8a..a2c1a0d90 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.138 — 2026-11-02
+
+### Patch changes
+
+- Updated dependencies: posthog@7.82.0
+
 ## 0.1.137 — 2026-11-02
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 5134031e3..4cb1475ca 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.137"
+version = "0.1.138"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 6a7aa5d85..5a1da5469 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,15 @@
 # posthog
 
+## 7.82.0 — 2026-11-02
+
+### Minor changes
+
+- [b10c38a](https://github.com/posthog/posthog-python/commit/b10c38ac3928f3b1cef743dab234e17720c81f08) Add a per-read `send_feature_flag_events` option to `FeatureFlagEvaluations.is_enabled()` and `get_flag()`. Pass `send_feature_flag_events=False` to read a flag from an `evaluate_flags()` snapshot without sending `$feature_flag_called`. The read leaves the dedupe cache alone, so a later read that sends events still reports the flag, and the key still counts as accessed for `only_accessed()`. The option defaults to `True`, as on `get_feature_flag()`. — Thanks @andehen!
+
+### Patch changes
+
+- [e24100b](https://github.com/posthog/posthog-python/commit/e24100b413d8f1a4f14c49dbee3391c8675fb2ff) Add `$feature_flag_id` and `$feature_flag_version` to `$feature_flag_called` events for locally evaluated flags in `get_feature_flag()`, `feature_enabled()` and `get_feature_flag_result()`, and `$feature_flag_version` for locally evaluated flags in `evaluate_flags()`, taken from the flag definition. Remotely evaluated flags already sent both. — Thanks @andehen!
+
 ## 7.81.2 — 2026-11-02
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index e1c8871d3..b866bd925 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.81.2"
+VERSION = "7.82.0"
diff --git a/pyproject.toml b/pyproject.toml
index f8e423654..f851336ab 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.81.2"
+version = "7.82.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 5294972b2..d26eb93e7 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.137"
+version = "0.1.138"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.81.2"
+version = "7.82.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 0a5417f62ae11f0570c1e514f7188042bbff4dc7 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 14:35:47 +0000
Subject: [PATCH 159/245] Update generated references

---
 .../posthog-python-references-7.82.0.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.82.0.json

diff --git a/references/posthog-python-references-7.82.0.json b/references/posthog-python-references-7.82.0.json
new file mode 100644
index 000000000..8c1c04a60
--- /dev/null
+++ b/references/posthog-python-references-7.82.0.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.82.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 15ba9a742..8c1c04a60 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.81.2",
+    "version": "7.82.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 9ebfb87ce3eefb2f3672c99e1b4f083013fe864b Mon Sep 17 00:00:00 2001
From: Sarbajit Sengupta <73594751+Sarbajit-Sengupta@users.noreply.github.com>
Date: Mon, 2 Nov 2026 21:26:40 +0530
Subject: [PATCH 160/245] fix(flags): treat concurrent fallback-cache eviction
 as a cache miss (#1167)

* fix(flags): treat concurrent cache eviction as a cache miss

* chore: add changeset for fallback cache eviction fix

---------

Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .sampo/changesets/sullen-wolfkin-erika.md     |  5 ++
 .../test/test_flag_cache_eviction_reads.py    | 65 +++++++++++++++++++
 posthog/utils.py                              | 16 ++---
 3 files changed, 78 insertions(+), 8 deletions(-)
 create mode 100644 .sampo/changesets/sullen-wolfkin-erika.md
 create mode 100644 posthog/test/test_flag_cache_eviction_reads.py

diff --git a/.sampo/changesets/sullen-wolfkin-erika.md b/.sampo/changesets/sullen-wolfkin-erika.md
new file mode 100644
index 000000000..3c6e6c064
--- /dev/null
+++ b/.sampo/changesets/sullen-wolfkin-erika.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Fix a race condition where concurrent feature flag fallback-cache eviction could raise KeyError instead of returning a cache miss, including during request failures.
diff --git a/posthog/test/test_flag_cache_eviction_reads.py b/posthog/test/test_flag_cache_eviction_reads.py
new file mode 100644
index 000000000..514ec9c75
--- /dev/null
+++ b/posthog/test/test_flag_cache_eviction_reads.py
@@ -0,0 +1,65 @@
+import pytest
+from requests.exceptions import ConnectionError
+
+from posthog.client import Client
+from posthog.types import FeatureFlagResult
+from posthog.utils import FlagCache
+
+
+class _EvictDuringRead(dict):
+    """Model a writer removing a key between a read's lookup operations."""
+
+    def __contains__(self, key):
+        present = super().__contains__(key)
+        self.pop(key, None)
+        return present
+
+    def get(self, key, default=None):
+        self.pop(key, None)
+        return super().get(key, default)
+
+
+@pytest.mark.parametrize("read_stale", [False, True])
+@pytest.mark.parametrize("evict_user", [False, True])
+def test_evicted_cache_entry_is_a_miss(read_stale, evict_user):
+    cache = FlagCache()
+    result = FeatureFlagResult.from_value_and_payload("flag", True, None)
+    cache.set_cached_flag("user", "flag", result, 1)
+    if evict_user:
+        cache.cache = _EvictDuringRead(cache.cache)
+    else:
+        cache.cache["user"] = _EvictDuringRead(cache.cache["user"])
+
+    if read_stale:
+        actual = cache.get_stale_cached_flag("user", "flag")
+    else:
+        actual = cache.get_cached_flag("user", "flag", 1)
+
+    assert actual is None
+    assert not cache.cache if evict_user else not cache.cache["user"]
+
+
+@pytest.mark.parametrize("evict_user", [False, True])
+def test_public_flag_lookup_survives_eviction_during_outage(monkeypatch, evict_user):
+    client = Client("test-key", send=False, enable_local_evaluation=False)
+    cache = FlagCache()
+    cache.set_cached_flag(
+        "user", "flag", FeatureFlagResult.from_value_and_payload("flag", True, None), 1
+    )
+    if evict_user:
+        cache.cache = _EvictDuringRead(cache.cache)
+    else:
+        cache.cache["user"] = _EvictDuringRead(cache.cache["user"])
+    client.flag_cache = cache
+
+    def unavailable(*args, **kwargs):
+        raise ConnectionError("offline test")
+
+    monkeypatch.setattr(client, "_get_feature_flag_details_from_server", unavailable)
+    try:
+        result = client.get_feature_flag_result(
+            "flag", "user", send_feature_flag_events=False
+        )
+        assert result is None
+    finally:
+        client.shutdown()
diff --git a/posthog/utils.py b/posthog/utils.py
index 05608983f..24e48a781 100644
--- a/posthog/utils.py
+++ b/posthog/utils.py
@@ -256,14 +256,14 @@ def _is_version_current(self, version):
     def get_cached_flag(self, distinct_id, flag_key, current_flag_version):
         current_time = time.time()
 
-        if distinct_id not in self.cache:
+        user_flags = self.cache.get(distinct_id)
+        if user_flags is None:
             return None
 
-        user_flags = self.cache[distinct_id]
-        if flag_key not in user_flags:
+        entry = user_flags.get(flag_key)
+        if entry is None:
             return None
 
-        entry = user_flags[flag_key]
         if self._is_version_current(entry.flag_definition_version) and entry.is_valid(
             current_time, self.default_ttl, current_flag_version
         ):
@@ -278,14 +278,14 @@ def get_stale_cached_flag(self, distinct_id, flag_key, max_stale_age=None):
 
         current_time = time.time()
 
-        if distinct_id not in self.cache:
+        user_flags = self.cache.get(distinct_id)
+        if user_flags is None:
             return None
 
-        user_flags = self.cache[distinct_id]
-        if flag_key not in user_flags:
+        entry = user_flags.get(flag_key)
+        if entry is None:
             return None
 
-        entry = user_flags[flag_key]
         if self._is_version_current(
             entry.flag_definition_version
         ) and entry.is_stale_but_usable(current_time, max_stale_age):

From 5b506837995c1ddbb007e8822221552c21b06748 Mon Sep 17 00:00:00 2001
From: Luan Taraschi <130802253+luantaraschi@users.noreply.github.com>
Date: Mon, 2 Nov 2026 12:58:10 -0300
Subject: [PATCH 161/245] fix(flags): stringify regex properties as compact
 JSON (#1157)

Local regex and not_regex matching called str() on the property.
---
 .../local-eval-regex-json-string.md           |  5 +++++
 posthog/feature_flags.py                      |  4 +++-
 posthog/test/test_feature_flags.py            | 19 +++++++++++++++++++
 3 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/local-eval-regex-json-string.md

diff --git a/.sampo/changesets/local-eval-regex-json-string.md b/.sampo/changesets/local-eval-regex-json-string.md
new file mode 100644
index 000000000..d7f44458d
--- /dev/null
+++ b/.sampo/changesets/local-eval-regex-json-string.md
@@ -0,0 +1,5 @@
+---
+posthog: patch
+---
+
+Stringify non-string properties as compact JSON for local `regex` and `not_regex` matching, so booleans, lists, and objects match the same way they do on the flags service.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index e0ffda658..cfe847fbb 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -1264,7 +1264,9 @@ def compute_exact_match(value, override_value):
         return matched
 
     if operator in ("regex", "not_regex"):
-        property_string = "null" if override_value is None else str(override_value)
+        property_string = _value_to_string(
+            override_value, UnresolvedFlagReason.MISSING_CONTEXT
+        )
         regex_match = _match_regex(str(value), property_string)
         if regex_match is None:
             return False
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index b52ec3bfa..eb89117b1 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -5871,6 +5871,25 @@ def test_match_properties_regex(self):
 
         self.assertFalse(match_property(property_d, {"key": "value"}))
 
+    @parameterized.expand(
+        [
+            ("list", r"\[1,2\]", [1, 2], True),
+            ("bool", "^true$", True, True),
+            ("python_bool_spelling", "True", True, False),
+            ("object", r'^\{"a":1,"b":\[null\]\}$', {"b": [None], "a": 1}, True),
+            ("python_object_spelling", "'a'", {"a": 1}, False),
+        ]
+    )
+    def test_regex_stringifies_non_string_properties_as_compact_json(
+        self, _name, pattern, property_value, expected
+    ):
+        regex = self.property("key", pattern, "regex")
+        not_regex = self.property("key", pattern, "not_regex")
+        self.assertEqual(expected, match_property(regex, {"key": property_value}))
+        self.assertEqual(
+            not expected, match_property(not_regex, {"key": property_value})
+        )
+
     def test_match_properties_math_operators(self):
         property_a = self.property(key="key", value=1, operator="gt")
         self.assertTrue(match_property(property_a, {"key": 2}))

From a239479585d5c5367843ec088e49f52010223d08 Mon Sep 17 00:00:00 2001
From: Luan Taraschi <130802253+luantaraschi@users.noreply.github.com>
Date: Mon, 2 Nov 2026 12:59:49 -0300
Subject: [PATCH 162/245] fix(flags): serialize UUID values in flags request
 bodies (#1156)

The flags request body goes straight to DatetimeSerializer without clean(), so a UUID distinct id, group key, or flag property raised TypeError. The SDK swallowed it and returned missing flags without sending a request. Serialize UUIDs as strings, matching what clean() already does for captured events.
---
 .sampo/changesets/flags-uuid-request-body.md |  5 +++
 posthog/request.py                           |  3 ++
 posthog/test/test_async_request.py           | 23 ++++++++++++++
 posthog/test/test_request.py                 | 32 ++++++++++++++++++++
 4 files changed, 63 insertions(+)
 create mode 100644 .sampo/changesets/flags-uuid-request-body.md

diff --git a/.sampo/changesets/flags-uuid-request-body.md b/.sampo/changesets/flags-uuid-request-body.md
new file mode 100644
index 000000000..af2ec63a3
--- /dev/null
+++ b/.sampo/changesets/flags-uuid-request-body.md
@@ -0,0 +1,5 @@
+---
+posthog: patch
+---
+
+Serialize UUID values in feature flag request bodies instead of failing the evaluation, so a UUID distinct id, group key, or flag property reaches the flags service.
diff --git a/posthog/request.py b/posthog/request.py
index f1816444d..5d4f07549 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -10,6 +10,7 @@
 from gzip import GzipFile
 from io import BytesIO
 from typing import Any, List, Optional, Tuple, Union, cast
+from uuid import UUID
 
 import requests
 from requests.adapters import HTTPAdapter
@@ -514,6 +515,8 @@ class DatetimeSerializer(json.JSONEncoder):
     def default(self, obj: Any):
         if isinstance(obj, (date, datetime)):
             return obj.isoformat()
+        if isinstance(obj, UUID):
+            return str(obj)
 
         return json.JSONEncoder.default(self, obj)
 
diff --git a/posthog/test/test_async_request.py b/posthog/test/test_async_request.py
index d95da855a..2cc9db24e 100644
--- a/posthog/test/test_async_request.py
+++ b/posthog/test/test_async_request.py
@@ -6,6 +6,7 @@
 import subprocess
 import sys
 from unittest import mock
+from uuid import UUID
 
 import httpx
 import pytest
@@ -252,6 +253,28 @@ async def test_async_flags_sends_v2_request_payload():
     assert "Authorization" not in kwargs["headers"]
 
 
+@pytest.mark.asyncio
+async def test_async_flags_sends_uuid_inputs_as_strings():
+    client = FakeAsyncClient(FakeResponse(200, {"flags": {}}))
+    user_id = UUID("12345678-1234-5678-1234-567812345678")
+    company_id = UUID("87654321-4321-8765-4321-876543218765")
+
+    await async_flags(
+        "project-key",
+        "https://example.com",
+        timeout=3,
+        max_retries=0,
+        client=client,
+        distinct_id=user_id,
+        groups={"company": company_id},
+    )
+
+    _, _, kwargs = client.calls[0]
+    payload = json.loads(kwargs["content"])
+    assert payload["distinct_id"] == str(user_id)
+    assert payload["groups"] == {"company": str(company_id)}
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("transient_statuses", "expected_delays"),
diff --git a/posthog/test/test_request.py b/posthog/test/test_request.py
index 455f24d82..e23b0a446 100644
--- a/posthog/test/test_request.py
+++ b/posthog/test/test_request.py
@@ -4,6 +4,7 @@
 import zlib
 from datetime import date, datetime, timedelta
 from unittest import mock
+from uuid import UUID
 
 import pytest
 import requests
@@ -265,6 +266,11 @@ def test_date_serialization(self):
         expected = '{"created": "%s"}' % today.isoformat()
         self.assertEqual(result, expected)
 
+    def test_uuid_serialization(self):
+        data = {"id": UUID("12345678-1234-5678-1234-567812345678")}
+        result = json.dumps(data, cls=DatetimeSerializer)
+        self.assertEqual(result, '{"id": "12345678-1234-5678-1234-567812345678"}')
+
     def test_should_not_timeout(self):
         response = requests.Response()
         response.status_code = 200
@@ -614,6 +620,32 @@ def test_flags_uses_flags_session(self, mock_get_flags_session):
         mock_get_flags_session.assert_called_once()
         mock_session.post.assert_called_once()
 
+    @mock.patch("posthog.request._get_flags_session")
+    def test_flags_sends_uuid_inputs_as_strings(self, mock_get_flags_session):
+        mock_response = requests.Response()
+        mock_response.status_code = 200
+        mock_response._content = json.dumps(
+            {"flags": {}, "errorsWhileComputingFlags": False}
+        ).encode("utf-8")
+        mock_session = mock.MagicMock()
+        mock_session.post.return_value = mock_response
+        mock_get_flags_session.return_value = mock_session
+        user_id = UUID("12345678-1234-5678-1234-567812345678")
+        company_id = UUID("87654321-4321-8765-4321-876543218765")
+
+        flags(
+            "test-key",
+            "https://test.posthog.com",
+            distinct_id=user_id,
+            groups={"company": company_id},
+            person_properties={"account_id": user_id},
+        )
+
+        body = json.loads(mock_session.post.call_args.kwargs["data"])
+        self.assertEqual(body["distinct_id"], str(user_id))
+        self.assertEqual(body["groups"], {"company": str(company_id)})
+        self.assertEqual(body["person_properties"], {"account_id": str(user_id)})
+
     @mock.patch("posthog.request._get_flags_session")
     def test_flags_no_retry_on_quota_limit(self, mock_get_flags_session):
         """flags() raises QuotaLimitError without retrying (at application level)."""

From 8c5e9df4360c3f147b6c9a21b36e40356d8b3c09 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 16:27:24 +0000
Subject: [PATCH 163/245] chore: Release v7.82.1 [skip ci]

---
 .sampo/changesets/flags-uuid-request-body.md      | 5 -----
 .sampo/changesets/local-eval-regex-json-string.md | 5 -----
 .sampo/changesets/sullen-wolfkin-erika.md         | 5 -----
 openfeature-provider/CHANGELOG.md                 | 6 ++++++
 openfeature-provider/pyproject.toml               | 2 +-
 posthog/CHANGELOG.md                              | 8 ++++++++
 posthog/version.py                                | 2 +-
 pyproject.toml                                    | 2 +-
 uv.lock                                           | 4 ++--
 9 files changed, 19 insertions(+), 20 deletions(-)
 delete mode 100644 .sampo/changesets/flags-uuid-request-body.md
 delete mode 100644 .sampo/changesets/local-eval-regex-json-string.md
 delete mode 100644 .sampo/changesets/sullen-wolfkin-erika.md

diff --git a/.sampo/changesets/flags-uuid-request-body.md b/.sampo/changesets/flags-uuid-request-body.md
deleted file mode 100644
index af2ec63a3..000000000
--- a/.sampo/changesets/flags-uuid-request-body.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-posthog: patch
----
-
-Serialize UUID values in feature flag request bodies instead of failing the evaluation, so a UUID distinct id, group key, or flag property reaches the flags service.
diff --git a/.sampo/changesets/local-eval-regex-json-string.md b/.sampo/changesets/local-eval-regex-json-string.md
deleted file mode 100644
index d7f44458d..000000000
--- a/.sampo/changesets/local-eval-regex-json-string.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-posthog: patch
----
-
-Stringify non-string properties as compact JSON for local `regex` and `not_regex` matching, so booleans, lists, and objects match the same way they do on the flags service.
diff --git a/.sampo/changesets/sullen-wolfkin-erika.md b/.sampo/changesets/sullen-wolfkin-erika.md
deleted file mode 100644
index 3c6e6c064..000000000
--- a/.sampo/changesets/sullen-wolfkin-erika.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Fix a race condition where concurrent feature flag fallback-cache eviction could raise KeyError instead of returning a cache miss, including during request failures.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index a2c1a0d90..c3617243e 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.139 — 2026-11-02
+
+### Patch changes
+
+- Updated dependencies: posthog@7.82.1
+
 ## 0.1.138 — 2026-11-02
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 4cb1475ca..33ddac4fa 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.138"
+version = "0.1.139"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5a1da5469..cf8ed5c75 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,13 @@
 # posthog
 
+## 7.82.1 — 2026-11-02
+
+### Patch changes
+
+- [9ebfb87](https://github.com/posthog/posthog-python/commit/9ebfb87ce3eefb2f3672c99e1b4f083013fe864b) Fix a race condition where concurrent feature flag fallback-cache eviction could raise KeyError instead of returning a cache miss, including during request failures. — Thanks @Sarbajit-Sengupta for your first contribution 🎉!
+- [5b50683](https://github.com/posthog/posthog-python/commit/5b506837995c1ddbb007e8822221552c21b06748) Stringify non-string properties as compact JSON for local `regex` and `not_regex` matching, so booleans, lists, and objects match the same way they do on the flags service. — Thanks @luantaraschi!
+- [a239479](https://github.com/posthog/posthog-python/commit/a239479585d5c5367843ec088e49f52010223d08) Serialize UUID values in feature flag request bodies instead of failing the evaluation, so a UUID distinct id, group key, or flag property reaches the flags service. — Thanks @luantaraschi!
+
 ## 7.82.0 — 2026-11-02
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index b866bd925..0c12967b2 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.82.0"
+VERSION = "7.82.1"
diff --git a/pyproject.toml b/pyproject.toml
index f851336ab..c235737f7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.82.0"
+version = "7.82.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index d26eb93e7..fcdb8dcfc 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.138"
+version = "0.1.139"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.82.0"
+version = "7.82.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From fbbd1099050f04284b60baed55cf8f7f5f7812b4 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 16:27:30 +0000
Subject: [PATCH 164/245] Update generated references

---
 .../posthog-python-references-7.82.1.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.82.1.json

diff --git a/references/posthog-python-references-7.82.1.json b/references/posthog-python-references-7.82.1.json
new file mode 100644
index 000000000..c69506f46
--- /dev/null
+++ b/references/posthog-python-references-7.82.1.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.82.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 8c1c04a60..c69506f46 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.82.0",
+    "version": "7.82.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 57b9db8493bc06dc448bda244020eea1e0ed1ec5 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Mon, 2 Nov 2026 15:23:12 -0500
Subject: [PATCH 165/245] fix(ai): count Gemini tool use prompt tokens as input
 tokens (#1164)

* fix(ai): count Gemini tool use prompt tokens as input tokens

Built-in tools (Google Search, URL context) report the retrieved content in
tool_use_prompt_token_count, separately from prompt_token_count, so input
tokens were under-reported on grounded responses.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>

* chore: add changeset for Gemini tool use prompt tokens

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>

* fix(ai): keep unbilled Google Search retrieval out of Gemini input tokens

tool_use_prompt_token_count is only added to input tokens when the response
carries url_context_metadata (billed as input); Search retrieval is not.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix(ai): carry Gemini URL context flag across stream chunks

URL context metadata can arrive on a different chunk than the final
usage_metadata, so the tool-use prompt tokens were dropped in streaming.
Track the flag across chunks in the sync and async clients.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

* fix(ci): format Gemini clients and refresh API snapshot

---------

Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .../gemini-tool-use-prompt-tokens.md          |  5 ++
 posthog/ai/gemini/gemini.py                   |  7 ++-
 posthog/ai/gemini/gemini_async.py             |  7 ++-
 posthog/ai/gemini/gemini_converter.py         | 43 ++++++++++++++--
 posthog/test/ai/gemini/test_gemini.py         | 37 ++++++++++++++
 posthog/test/ai/gemini/test_gemini_async.py   | 37 ++++++++++++++
 .../test/ai/gemini/test_gemini_converter.py   | 50 +++++++++++++++++++
 references/public_api_snapshot.txt            |  5 +-
 8 files changed, 183 insertions(+), 8 deletions(-)
 create mode 100644 .sampo/changesets/gemini-tool-use-prompt-tokens.md

diff --git a/.sampo/changesets/gemini-tool-use-prompt-tokens.md b/.sampo/changesets/gemini-tool-use-prompt-tokens.md
new file mode 100644
index 000000000..6c5f98d9a
--- /dev/null
+++ b/.sampo/changesets/gemini-tool-use-prompt-tokens.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Count Gemini URL context tool use prompt tokens as input tokens in captured generations; Google Search retrieval is not billed as input and stays out of the total.
diff --git a/posthog/ai/gemini/gemini.py b/posthog/ai/gemini/gemini.py
index dad87da9a..485e2adee 100644
--- a/posthog/ai/gemini/gemini.py
+++ b/posthog/ai/gemini/gemini.py
@@ -25,6 +25,7 @@
     extract_gemini_embedding_token_count as extract_gemini_embedding_token_count,
     extract_gemini_stop_reason_from_chunk,
     extract_gemini_usage_from_chunk,
+    has_gemini_url_context,
     format_gemini_streaming_output as format_gemini_streaming_output,
 )
 
@@ -267,10 +268,14 @@ def generator():
             nonlocal accumulated_content
             nonlocal stop_reason
             stream_error: Optional[BaseException] = None
+            url_context_seen = False
             try:
                 for chunk in response:
                     # Extract usage stats from chunk
-                    chunk_usage = extract_gemini_usage_from_chunk(chunk)
+                    url_context_seen = url_context_seen or has_gemini_url_context(chunk)
+                    chunk_usage = extract_gemini_usage_from_chunk(
+                        chunk, url_context_seen=url_context_seen
+                    )
 
                     if chunk_usage:
                         # Gemini reports cumulative totals, not incremental values
diff --git a/posthog/ai/gemini/gemini_async.py b/posthog/ai/gemini/gemini_async.py
index 6c70efd9b..6823743ed 100644
--- a/posthog/ai/gemini/gemini_async.py
+++ b/posthog/ai/gemini/gemini_async.py
@@ -25,6 +25,7 @@
     extract_gemini_embedding_token_count as extract_gemini_embedding_token_count,
     extract_gemini_stop_reason_from_chunk,
     extract_gemini_usage_from_chunk,
+    has_gemini_url_context,
     format_gemini_streaming_output as format_gemini_streaming_output,
 )
 
@@ -254,10 +255,14 @@ async def async_generator():
             nonlocal stop_reason
 
             stream_error: Optional[BaseException] = None
+            url_context_seen = False
             try:
                 async for chunk in response:
                     # Extract usage stats from chunk
-                    chunk_usage = extract_gemini_usage_from_chunk(chunk)
+                    url_context_seen = url_context_seen or has_gemini_url_context(chunk)
+                    chunk_usage = extract_gemini_usage_from_chunk(
+                        chunk, url_context_seen=url_context_seen
+                    )
 
                     if chunk_usage:
                         # Gemini reports cumulative totals, not incremental values
diff --git a/posthog/ai/gemini/gemini_converter.py b/posthog/ai/gemini/gemini_converter.py
index 09ae82d25..81b4f630b 100644
--- a/posthog/ai/gemini/gemini_converter.py
+++ b/posthog/ai/gemini/gemini_converter.py
@@ -517,19 +517,42 @@ def extract_gemini_web_search_count(response: Any) -> int:
     return 0
 
 
-def _extract_usage_from_metadata(metadata: Any) -> TokenUsage:
+def has_gemini_url_context(response: Any) -> bool:
+    """Whether a response or chunk carries URL context retrieval metadata."""
+    candidates = getattr(response, "candidates", None)
+    if not isinstance(candidates, (list, tuple)):
+        return False
+    return any(getattr(c, "url_context_metadata", None) for c in candidates)
+
+
+def _extract_usage_from_metadata(
+    metadata: Any, bill_tool_use_tokens: bool = False
+) -> TokenUsage:
     """
     Common logic to extract usage from Gemini metadata.
     Used by both streaming and non-streaming paths.
 
     Args:
         metadata: usage_metadata from Gemini response or chunk
+        bill_tool_use_tokens: whether tool_use_prompt_token_count is billed as
+            input (URL context). Google Search retrieval is not billed as input.
 
     Returns:
         TokenUsage with standardized usage
     """
+    input_tokens = getattr(metadata, "prompt_token_count", 0)
+
+    # Built-in tools report the retrieved content separately from
+    # prompt_token_count. URL context content is billed as input; Google Search
+    # retrieval is not, so only add it when the response used URL context.
+    # (A response that used both tools cannot be split from these counts.)
+    if bill_tool_use_tokens:
+        tool_use_tokens = getattr(metadata, "tool_use_prompt_token_count", 0)
+        if isinstance(tool_use_tokens, int) and tool_use_tokens > 0:
+            input_tokens += tool_use_tokens
+
     usage = TokenUsage(
-        input_tokens=getattr(metadata, "prompt_token_count", 0),
+        input_tokens=input_tokens,
         output_tokens=getattr(metadata, "candidates_token_count", 0),
     )
 
@@ -573,7 +596,9 @@ def extract_gemini_usage_from_response(response: Any) -> TokenUsage:
     if not hasattr(response, "usage_metadata") or not response.usage_metadata:
         return TokenUsage()
 
-    usage = _extract_usage_from_metadata(response.usage_metadata)
+    usage = _extract_usage_from_metadata(
+        response.usage_metadata, bill_tool_use_tokens=has_gemini_url_context(response)
+    )
 
     # Add web search count if present
     web_search_count = extract_gemini_web_search_count(response)
@@ -583,12 +608,17 @@ def extract_gemini_usage_from_response(response: Any) -> TokenUsage:
     return usage
 
 
-def extract_gemini_usage_from_chunk(chunk: Any) -> TokenUsage:
+def extract_gemini_usage_from_chunk(
+    chunk: Any, url_context_seen: bool = False
+) -> TokenUsage:
     """
     Extract usage statistics from a Gemini streaming chunk.
 
     Args:
         chunk: Streaming chunk from Gemini API
+        url_context_seen: whether an earlier chunk of the same stream carried
+            URL context metadata. Tool indicators can arrive on a different
+            chunk than the final usage_metadata, so callers carry this flag.
 
     Returns:
         TokenUsage with standardized usage statistics
@@ -605,7 +635,10 @@ def extract_gemini_usage_from_chunk(chunk: Any) -> TokenUsage:
     if not hasattr(chunk, "usage_metadata") or not chunk.usage_metadata:
         return usage
 
-    usage_from_metadata = _extract_usage_from_metadata(chunk.usage_metadata)
+    usage_from_metadata = _extract_usage_from_metadata(
+        chunk.usage_metadata,
+        bill_tool_use_tokens=url_context_seen or has_gemini_url_context(chunk),
+    )
 
     # Merge the usage from metadata with any web search count we found
     usage.update(usage_from_metadata)
diff --git a/posthog/test/ai/gemini/test_gemini.py b/posthog/test/ai/gemini/test_gemini.py
index b616dcd89..c5e8409b3 100644
--- a/posthog/test/ai/gemini/test_gemini.py
+++ b/posthog/test/ai/gemini/test_gemini.py
@@ -1741,3 +1741,40 @@ def test_ai_lane_client_routes_through_capture_ai(
     mock_client.capture.assert_not_called()
     assert mock_client.capture_ai.call_count == 1
     assert mock_client.capture_ai.call_args[1]["event"] == "$ai_generation"
+
+
+def _url_context_stream_chunks():
+    from google.genai import types
+
+    # URL context metadata arrives on an early chunk; usage on the last one.
+    first = types.GenerateContentResponse(
+        candidates=[types.Candidate(url_context_metadata=types.UrlContextMetadata())]
+    )
+    last = types.GenerateContentResponse(
+        usage_metadata=types.GenerateContentResponseUsageMetadata(
+            prompt_token_count=20,
+            tool_use_prompt_token_count=300,
+            candidates_token_count=10,
+            total_token_count=330,
+        )
+    )
+    return first, last
+
+
+def test_streaming_url_context_on_earlier_chunk_bills_tool_use_tokens(
+    mock_client, mock_google_genai_client
+):
+    first, last = _url_context_stream_chunks()
+    mock_google_genai_client.models.generate_content_stream.return_value = iter(
+        [first, last]
+    )
+
+    client = Client(api_key="test-key", posthog_client=mock_client)
+    response = client.models.generate_content_stream(
+        model="gemini-2.0-flash", contents=["Summarise this page"]
+    )
+    list(response)
+
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_input_tokens"] == 320
+    assert props["$ai_output_tokens"] == 10
diff --git a/posthog/test/ai/gemini/test_gemini_async.py b/posthog/test/ai/gemini/test_gemini_async.py
index b4e63c019..9cdc0fdbb 100644
--- a/posthog/test/ai/gemini/test_gemini_async.py
+++ b/posthog/test/ai/gemini/test_gemini_async.py
@@ -1178,3 +1178,40 @@ async def mock_streaming_response():
     call_args = mock_client.capture.call_args[1]
     assert call_args["event"] == "$ai_generation"
     assert call_args["properties"]["$ai_provider"] == "gemini"
+
+
+async def test_async_streaming_url_context_on_earlier_chunk_bills_tool_use_tokens(
+    mock_client, mock_google_genai_client
+):
+    from google.genai import types
+
+    first = types.GenerateContentResponse(
+        candidates=[types.Candidate(url_context_metadata=types.UrlContextMetadata())]
+    )
+    last = types.GenerateContentResponse(
+        usage_metadata=types.GenerateContentResponseUsageMetadata(
+            prompt_token_count=20,
+            tool_use_prompt_token_count=300,
+            candidates_token_count=10,
+            total_token_count=330,
+        )
+    )
+
+    async def stream():
+        yield first
+        yield last
+
+    mock_google_genai_client.aio.models.generate_content_stream = AsyncMock(
+        return_value=stream()
+    )
+
+    client = AsyncClient(api_key="test-key", posthog_client=mock_client)
+    response = await client.models.generate_content_stream(
+        model="gemini-2.0-flash", contents=["Summarise this page"]
+    )
+    async for _ in response:
+        pass
+
+    props = mock_client.capture.call_args[1]["properties"]
+    assert props["$ai_input_tokens"] == 320
+    assert props["$ai_output_tokens"] == 10
diff --git a/posthog/test/ai/gemini/test_gemini_converter.py b/posthog/test/ai/gemini/test_gemini_converter.py
index 7cdd211c7..4227b6d08 100644
--- a/posthog/test/ai/gemini/test_gemini_converter.py
+++ b/posthog/test/ai/gemini/test_gemini_converter.py
@@ -10,7 +10,9 @@
     GEMINI_AVAILABLE = False
 
 from posthog.ai.gemini.gemini_converter import (
+    extract_gemini_usage_from_chunk,
     extract_gemini_content_from_chunk,
+    extract_gemini_usage_from_response,
     format_gemini_input,
     format_gemini_response,
     format_gemini_streaming_output,
@@ -311,3 +313,51 @@ def test_streaming_chunk_thought_part_becomes_thinking_block(self):
             {"type": "thinking", "thinking": "Hmm, "},
             {"type": "text", "text": "done"},
         ]
+
+
+class TestGeminiUsage:
+    @staticmethod
+    def _response(**candidate_kwargs):
+        return types.GenerateContentResponse(
+            candidates=[types.Candidate(**candidate_kwargs)],
+            usage_metadata=types.GenerateContentResponseUsageMetadata(
+                prompt_token_count=20,
+                tool_use_prompt_token_count=300,
+                candidates_token_count=10,
+                total_token_count=330,
+            ),
+        )
+
+    def test_url_context_tool_use_tokens_count_as_input(self):
+        # URL context content is billed as input.
+        resp = self._response(url_context_metadata=types.UrlContextMetadata())
+        for extract in (
+            extract_gemini_usage_from_response,
+            extract_gemini_usage_from_chunk,
+        ):
+            usage = extract(resp)
+            assert usage["input_tokens"] == 320
+            assert usage["output_tokens"] == 10
+
+    def test_search_retrieval_tokens_are_not_billed_as_input(self):
+        # Google Search retrieval is reported in tool_use_prompt_token_count but
+        # is not charged as input.
+        resp = self._response(
+            grounding_metadata=types.GroundingMetadata(web_search_queries=["q"])
+        )
+        for extract in (
+            extract_gemini_usage_from_response,
+            extract_gemini_usage_from_chunk,
+        ):
+            assert extract(resp)["input_tokens"] == 20
+
+    def test_input_tokens_without_tool_use(self):
+        resp = types.GenerateContentResponse(
+            usage_metadata=types.GenerateContentResponseUsageMetadata(
+                prompt_token_count=20,
+                candidates_token_count=10,
+                total_token_count=30,
+            )
+        )
+        usage = extract_gemini_usage_from_response(resp)
+        assert usage["input_tokens"] == 20
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index db204f127..5f03d188d 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -113,6 +113,7 @@ alias posthog.ai.gemini.gemini.extract_gemini_stop_reason_from_chunk -> posthog.
 alias posthog.ai.gemini.gemini.extract_gemini_usage_from_chunk -> posthog.ai.gemini.gemini_converter.extract_gemini_usage_from_chunk
 alias posthog.ai.gemini.gemini.finalize_ai_content -> posthog.ai.utils.finalize_ai_content
 alias posthog.ai.gemini.gemini.format_gemini_streaming_output -> posthog.ai.gemini.gemini_converter.format_gemini_streaming_output
+alias posthog.ai.gemini.gemini.has_gemini_url_context -> posthog.ai.gemini.gemini_converter.has_gemini_url_context
 alias posthog.ai.gemini.gemini.merge_system_prompt -> posthog.ai.utils.merge_system_prompt
 alias posthog.ai.gemini.gemini.merge_usage_stats -> posthog.ai.utils.merge_usage_stats
 alias posthog.ai.gemini.gemini.setup -> posthog.setup
@@ -129,6 +130,7 @@ alias posthog.ai.gemini.gemini_async.extract_gemini_stop_reason_from_chunk -> po
 alias posthog.ai.gemini.gemini_async.extract_gemini_usage_from_chunk -> posthog.ai.gemini.gemini_converter.extract_gemini_usage_from_chunk
 alias posthog.ai.gemini.gemini_async.finalize_ai_content -> posthog.ai.utils.finalize_ai_content
 alias posthog.ai.gemini.gemini_async.format_gemini_streaming_output -> posthog.ai.gemini.gemini_converter.format_gemini_streaming_output
+alias posthog.ai.gemini.gemini_async.has_gemini_url_context -> posthog.ai.gemini.gemini_converter.has_gemini_url_context
 alias posthog.ai.gemini.gemini_async.merge_system_prompt -> posthog.ai.utils.merge_system_prompt
 alias posthog.ai.gemini.gemini_async.merge_usage_stats -> posthog.ai.utils.merge_usage_stats
 alias posthog.ai.gemini.gemini_async.setup -> posthog.setup
@@ -1414,13 +1416,14 @@ function posthog.ai.gemini.gemini_converter.extract_gemini_stop_reason(response:
 function posthog.ai.gemini.gemini_converter.extract_gemini_stop_reason_from_chunk(chunk: Any) -> Optional[str]
 function posthog.ai.gemini.gemini_converter.extract_gemini_system_instruction(config: Any) -> Optional[str]
 function posthog.ai.gemini.gemini_converter.extract_gemini_tools(kwargs: Dict[str, Any]) -> Optional[Any]
-function posthog.ai.gemini.gemini_converter.extract_gemini_usage_from_chunk(chunk: Any) -> TokenUsage
+function posthog.ai.gemini.gemini_converter.extract_gemini_usage_from_chunk(chunk: Any, url_context_seen: bool = False) -> TokenUsage
 function posthog.ai.gemini.gemini_converter.extract_gemini_usage_from_response(response: Any) -> TokenUsage
 function posthog.ai.gemini.gemini_converter.extract_gemini_web_search_count(response: Any) -> int
 function posthog.ai.gemini.gemini_converter.format_gemini_input(contents: Any) -> List[FormattedMessage]
 function posthog.ai.gemini.gemini_converter.format_gemini_input_with_system(contents: Any, config: Any = None) -> List[FormattedMessage]
 function posthog.ai.gemini.gemini_converter.format_gemini_response(response: Any) -> List[FormattedMessage]
 function posthog.ai.gemini.gemini_converter.format_gemini_streaming_output(accumulated_content: Union[str, List[Any]]) -> List[FormattedMessage]
+function posthog.ai.gemini.gemini_converter.has_gemini_url_context(response: Any) -> bool
 function posthog.ai.media.bytes_to_base64(data: bytes) -> str
 function posthog.ai.media.ensure_serializable(obj: Any) -> Any
 function posthog.ai.media.normalize_part_keys(d: dict) -> dict

From 16e99f0aa233a3fc325677efebf271b5c8b8e2a8 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 20:34:58 +0000
Subject: [PATCH 166/245] chore: Release v7.82.2 [skip ci]

---
 .sampo/changesets/gemini-tool-use-prompt-tokens.md | 5 -----
 openfeature-provider/CHANGELOG.md                  | 6 ++++++
 openfeature-provider/pyproject.toml                | 2 +-
 posthog/CHANGELOG.md                               | 6 ++++++
 posthog/version.py                                 | 2 +-
 pyproject.toml                                     | 2 +-
 uv.lock                                            | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/gemini-tool-use-prompt-tokens.md

diff --git a/.sampo/changesets/gemini-tool-use-prompt-tokens.md b/.sampo/changesets/gemini-tool-use-prompt-tokens.md
deleted file mode 100644
index 6c5f98d9a..000000000
--- a/.sampo/changesets/gemini-tool-use-prompt-tokens.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Count Gemini URL context tool use prompt tokens as input tokens in captured generations; Google Search retrieval is not billed as input and stays out of the total.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index c3617243e..855f7952f 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.140 — 2026-11-02
+
+### Patch changes
+
+- Updated dependencies: posthog@7.82.2
+
 ## 0.1.139 — 2026-11-02
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 33ddac4fa..f6a41813d 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.139"
+version = "0.1.140"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index cf8ed5c75..333c2e0d7 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.82.2 — 2026-11-02
+
+### Patch changes
+
+- [57b9db8](https://github.com/posthog/posthog-python/commit/57b9db8493bc06dc448bda244020eea1e0ed1ec5) Count Gemini URL context tool use prompt tokens as input tokens in captured generations; Google Search retrieval is not billed as input and stays out of the total. — Thanks @pcbeingused333!
+
 ## 7.82.1 — 2026-11-02
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 0c12967b2..798aad33f 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.82.1"
+VERSION = "7.82.2"
diff --git a/pyproject.toml b/pyproject.toml
index c235737f7..da14bebf7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.82.1"
+version = "7.82.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index fcdb8dcfc..9efc09a70 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.139"
+version = "0.1.140"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.82.1"
+version = "7.82.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 1dfca270eb9f3aa3edced416d79f2ff0bc308185 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 2 Nov 2026 20:35:05 +0000
Subject: [PATCH 167/245] Update generated references

---
 .../posthog-python-references-7.82.2.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.82.2.json

diff --git a/references/posthog-python-references-7.82.2.json b/references/posthog-python-references-7.82.2.json
new file mode 100644
index 000000000..39752929b
--- /dev/null
+++ b/references/posthog-python-references-7.82.2.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.82.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "int",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "int",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index c69506f46..39752929b 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.82.1",
+    "version": "7.82.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From e094dc59522b8d7d7b68a74cac4259a61daef60f Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Tue, 3 Nov 2026 13:59:47 +0100
Subject: [PATCH 168/245] feat(flags): read the /flags?v=4 response (#1031)

---
 .github/workflows/sdk-compliance.yml          |    4 +-
 .sampo/changesets/flags-v4-response.md        |    5 +
 posthog/_async_request.py                     |    2 +-
 posthog/async_client.py                       |   36 +-
 posthog/client.py                             |   58 +-
 posthog/feature_flag_evaluations.py           |   72 +-
 posthog/request.py                            |    2 +-
 .../feature_flag_rules_v2/SOURCE.json         |   26 +
 .../legacy_projection.json                    |  661 ++++
 .../feature_flag_rules_v2/readers.json        | 1078 ++++++
 .../feature_flag_rules_v2/responses.json      | 1151 ++++++
 .../v2_value_evaluation.json                  | 3080 +++++++++++++++++
 .../test/fixtures/released_flags_7_82_1.json  | 2258 ++++++++++++
 posthog/test/released_flags_scenarios.py      |  319 ++
 posthog/test/snapshots/flags_request.json     |    2 +-
 posthog/test/test_async_request.py            |    2 +-
 posthog/test/test_feature_flag.py             |    2 +-
 posthog/test/test_flags_released_behaviour.py |   75 +
 posthog/test/test_flags_v4_response.py        | 1186 +++++++
 posthog/types.py                              |  336 +-
 references/public_api_snapshot.txt            |    6 +-
 sdk_compliance_adapter/adapter.py             |    2 +
 sdk_compliance_adapter/test_adapter.py        |    1 +
 23 files changed, 10272 insertions(+), 92 deletions(-)
 create mode 100644 .sampo/changesets/flags-v4-response.md
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/legacy_projection.json
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/readers.json
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/responses.json
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/v2_value_evaluation.json
 create mode 100644 posthog/test/fixtures/released_flags_7_82_1.json
 create mode 100644 posthog/test/released_flags_scenarios.py
 create mode 100644 posthog/test/test_flags_released_behaviour.py
 create mode 100644 posthog/test/test_flags_v4_response.py

diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index b200a0dc1..2df4d111c 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -33,7 +33,7 @@ jobs:
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
-      test-harness-version: "1.1.1"
+      test-harness-version: "1.23.0"
       continue-on-error: false
       report-name: "sdk-compliance-report-v0"
 
@@ -43,6 +43,6 @@ jobs:
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."
-      test-harness-version: "1.1.1"
+      test-harness-version: "1.23.0"
       continue-on-error: false
       report-name: "sdk-compliance-report-v1"
diff --git a/.sampo/changesets/flags-v4-response.md b/.sampo/changesets/flags-v4-response.md
new file mode 100644
index 000000000..829f5b02f
--- /dev/null
+++ b/.sampo/changesets/flags-v4-response.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Request `/flags?v=4` and read each flag's typed value, reason and metadata. They stay internal for now: this release adds no public methods, fields or types for them, and `repr`, equality and `dataclasses.asdict` of a flag show only its existing fields. Servers that still send the older response keep working, and a flag record with a field of the wrong JSON type fails only that flag. For valid flag records, existing getters, callbacks and `$feature_flag_called` properties return the same values as before: a number or object value reads as `True`, with the value as its payload. Two things can differ: the human-readable reason text of a config version 2 flag is the one the server sends at v4, and a record with a known field of the wrong JSON type (for example a string `reason`) now reads as a failed flag instead of being read anyway or failing the whole response. The SDK logs once per client when a server sends a response without typed values. `FlagMetadata.id` and `FlagMetadata.version` are `None` when a record has none, instead of `0`, so their type is now `Optional[int]`.
diff --git a/posthog/_async_request.py b/posthog/_async_request.py
index 00120971a..50dfe829c 100644
--- a/posthog/_async_request.py
+++ b/posthog/_async_request.py
@@ -149,7 +149,7 @@ async def async_flags(
                     _serialize_flags_body, api_key, request_data
                 )
                 response = await http_client.post(
-                    "/flags/?v=2", content=data, headers=headers, timeout=timeout
+                    "/flags/?v=4", content=data, headers=headers, timeout=timeout
                 )
                 return await asyncio.to_thread(_process_flags_response, response)
             except httpx_module.TransportError:
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 57ed13e29..72f7cd2fe 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -40,8 +40,6 @@
     MAX_DICT_SIZE as _MAX_DICT_SIZE,
     _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES,
     Client as _SyncClient,
-    _metadata_has_experiment,
-    _parse_flag_payload,
     add_context_tags as _add_context_tags,
     get_identity_state as _get_identity_state,
     stringify_id as _stringify_id,
@@ -74,11 +72,17 @@
 from .feature_flag_evaluations import (
     FeatureFlagEvaluations,
     _EvaluatedFlagRecord,
+    _RemoteFlagRecord,
     _FeatureFlagEvaluationsHost,
 )
 from .release_id import _resolve_release_id
 from .request import QuotaLimitError, determine_server_host, normalize_host
-from .types import FlagMetadata, FlagValue, normalize_flags_response
+from .types import (
+    FlagValue,
+    _has_untyped_flag_records,
+    _UNTYPED_FLAGS_RESPONSE_MESSAGE,
+    normalize_flags_response,
+)
 from .utils import SizeLimitedDict, _normalize_timestamp, clean, system_context
 from .version import VERSION
 
@@ -231,6 +235,8 @@ def __init__(
             self.log.setLevel(logging.DEBUG)
         else:
             self.log.setLevel(logging.WARNING)
+        # Whether this client has logged that /flags sent records without typed values.
+        self._logged_untyped_flags_response = False
 
         if not self.api_key:
             self.log.error(
@@ -927,6 +933,11 @@ async def _get_flags_decision(
             client=self._get_http_client(),
             **request_data,
         )
+        if not self._logged_untyped_flags_response and _has_untyped_flag_records(
+            response
+        ):
+            self._logged_untyped_flags_response = True
+            self.log.info(_UNTYPED_FLAGS_RESPONSE_MESSAGE)
         return normalize_flags_response(response)
 
     async def evaluate_flags(
@@ -1004,24 +1015,7 @@ async def evaluate_flags(
             for key, detail in response.get("flags", {}).items():
                 if requested_keys is not None and key not in requested_keys:
                     continue
-                metadata = detail.metadata
-                records[key] = _EvaluatedFlagRecord(
-                    key=key,
-                    enabled=detail.enabled,
-                    variant=detail.variant,
-                    payload=_parse_flag_payload(metadata.payload),
-                    id=metadata.id if isinstance(metadata, FlagMetadata) else None,
-                    version=(
-                        metadata.version if isinstance(metadata, FlagMetadata) else None
-                    ),
-                    reason=(
-                        detail.reason.description
-                        if detail.reason and detail.reason.description
-                        else None
-                    ),
-                    locally_evaluated=False,
-                    has_experiment=_metadata_has_experiment(metadata),
-                )
+                records[key] = _RemoteFlagRecord(detail)
         except QuotaLimitError:
             self.log.warning(
                 "[FEATURE FLAGS] Feature flag evaluation was quota limited"
diff --git a/posthog/client.py b/posthog/client.py
index 3db53ea74..ce5eb3352 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -77,7 +77,9 @@
 )
 from posthog.feature_flag_evaluations import (
     FeatureFlagEvaluations,
+    _LocalFlagRecord,
     _EvaluatedFlagRecord,
+    _RemoteFlagRecord,
     _FeatureFlagEvaluationsHost,
 )
 from posthog.feature_flags import (
@@ -123,6 +125,8 @@
     FlagValue,
     SendFeatureFlagsOptions,
     UnresolvedFlagReason,
+    _has_untyped_flag_records,
+    _UNTYPED_FLAGS_RESPONSE_MESSAGE,
     normalize_flags_response,
     to_flags_and_payloads,
     to_payloads,
@@ -1016,6 +1020,8 @@ def __init__(
         # the /flags v2 response and the local-evaluation payload. False until the
         # server reports it, so full events are the fail-safe.
         self._minimal_flag_called_events: bool = False
+        # Whether this client has logged that /flags sent records without typed values.
+        self._logged_untyped_flags_response = False
 
         self.capture_trace_context = capture_trace_context
         self.capture_exception_code_variables = capture_exception_code_variables
@@ -1716,6 +1722,11 @@ def _get_flags_decision(
             **request_data,
         )
 
+        if not self._logged_untyped_flags_response and _has_untyped_flag_records(
+            resp_data
+        ):
+            self._logged_untyped_flags_response = True
+            self.log.info(_UNTYPED_FLAGS_RESPONSE_MESSAGE)
         response = normalize_flags_response(resp_data)
         # Server-controlled gate for minimal $feature_flag_called events. Only the
         # v2 response shape carries it; absent (legacy shape, older server, team
@@ -4172,9 +4183,23 @@ def _get_feature_flag_result(
                     flag_details, override_match_value
                 )
 
+                if (
+                    flag_details is not None
+                    and flag_details._malformed_field is not None
+                ):
+                    # The record could not be read, so it reads as disabled. It must
+                    # not replace the last good cached value, which it falls back to
+                    # like a failed request, and it reports what a failed request
+                    # reports: an unknown error and no request details.
+                    feature_flag_error = FeatureFlagError.UNKNOWN_ERROR
+                    request_id = None
+                    evaluated_at = None
+                    flag_result = (
+                        self._get_stale_flag_fallback(distinct_id, key) or flag_result
+                    )
                 # The request-start generation is an invalidation boundary, not
                 # a claim about the server's definitions. Refresh rejects late writes.
-                if self.flag_cache and flag_result:
+                elif self.flag_cache and flag_result:
                     self.flag_cache._set_cached_remote_flag(
                         distinct_id, key, flag_result, local_definition_version
                     )
@@ -4991,7 +5016,7 @@ def evaluate_flags(
 
         for key, value in local_flags.items():
             flag_def = feature_flags_by_key.get(key) or {}
-            records[key] = _EvaluatedFlagRecord(
+            records[key] = _LocalFlagRecord(
                 key=key,
                 enabled=value is not False,
                 variant=value if isinstance(value, str) else None,
@@ -5034,34 +5059,7 @@ def evaluate_flags(
                         continue
                     if key in locally_evaluated_keys:
                         continue
-                    payload = _parse_flag_payload(
-                        detail.metadata.payload
-                        if isinstance(detail.metadata, FlagMetadata)
-                        else getattr(detail.metadata, "payload", None)
-                    )
-                    records[key] = _EvaluatedFlagRecord(
-                        key=key,
-                        enabled=detail.enabled,
-                        variant=detail.variant,
-                        payload=payload,
-                        id=(
-                            detail.metadata.id
-                            if isinstance(detail.metadata, FlagMetadata)
-                            else None
-                        ),
-                        version=(
-                            detail.metadata.version
-                            if isinstance(detail.metadata, FlagMetadata)
-                            else None
-                        ),
-                        reason=(
-                            detail.reason.description
-                            if detail.reason and detail.reason.description
-                            else None
-                        ),
-                        locally_evaluated=False,
-                        has_experiment=_metadata_has_experiment(detail.metadata),
-                    )
+                    records[key] = _RemoteFlagRecord(detail)
             except QuotaLimitError as e:
                 self.log.warning(f"[FEATURE FLAGS] Quota limit exceeded: {e}")
                 quota_limited = True
diff --git a/posthog/feature_flag_evaluations.py b/posthog/feature_flag_evaluations.py
index ef4859b46..28e5bf31e 100644
--- a/posthog/feature_flag_evaluations.py
+++ b/posthog/feature_flag_evaluations.py
@@ -9,12 +9,14 @@
 from types import MappingProxyType
 from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Union
 
-from posthog.types import FlagValue, UnresolvedFlagReason
+from .types import FeatureFlag as _FeatureFlag
+from .types import FlagMetadata as _FlagMetadata
+from .types import FlagValue, UnresolvedFlagReason, _parse_flag_payload
 
 
 @dataclass(frozen=True)
-class _EvaluatedFlagRecord:
-    """Internal per-flag record stored by a FeatureFlagEvaluations instance."""
+class _LocalFlagRecord:
+    """Internal per-flag record of a locally evaluated flag."""
 
     key: str
     enabled: bool
@@ -29,6 +31,70 @@ class _EvaluatedFlagRecord:
     has_experiment: Optional[bool] = None
 
 
+_UNDECODED: Any = object()
+
+
+class _RemoteFlagRecord:
+    """Internal per-flag record of a remotely evaluated flag.
+
+    The parsed ``/flags`` record is the only copy of the flag: the record fields are
+    read from it, and the payload is decoded on its first read and then kept.
+    """
+
+    __slots__ = ("details", "_payload")
+
+    locally_evaluated = False
+
+    def __init__(self, details: _FeatureFlag) -> None:
+        # The parsed /flags record, with its typed value, reason and metadata.
+        self.details = details
+        self._payload: Any = _UNDECODED
+
+    @property
+    def key(self) -> str:
+        return self.details.key
+
+    @property
+    def enabled(self) -> bool:
+        return self.details.enabled
+
+    @property
+    def variant(self) -> Optional[str]:
+        return self.details.variant
+
+    @property
+    def payload(self) -> Optional[Any]:
+        if self._payload is _UNDECODED:
+            self._payload = _parse_flag_payload(
+                getattr(self.details.metadata, "payload", None)
+            )
+        return self._payload
+
+    @property
+    def id(self) -> Optional[int]:
+        metadata = self.details.metadata
+        return metadata.id if isinstance(metadata, _FlagMetadata) else None
+
+    @property
+    def version(self) -> Optional[int]:
+        metadata = self.details.metadata
+        return metadata.version if isinstance(metadata, _FlagMetadata) else None
+
+    @property
+    def reason(self) -> Optional[str]:
+        reason = self.details.reason
+        return reason.description if reason and reason.description else None
+
+    @property
+    def has_experiment(self) -> Optional[bool]:
+        metadata = self.details.metadata
+        return metadata.has_experiment if isinstance(metadata, _FlagMetadata) else None
+
+
+# The per-flag record stored by a FeatureFlagEvaluations instance.
+_EvaluatedFlagRecord = Union[_LocalFlagRecord, _RemoteFlagRecord]
+
+
 @dataclass
 class _FeatureFlagEvaluationsHost:
     """Callbacks the evaluations object uses to talk back to the client.
diff --git a/posthog/request.py b/posthog/request.py
index 5d4f07549..03316fc1f 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -344,7 +344,7 @@ def flags(
             res = post(
                 api_key,
                 host,
-                "/flags/?v=2",
+                "/flags/?v=4",
                 gzip,
                 timeout,
                 session=_get_flags_session(),
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json b/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
new file mode 100644
index 000000000..df7f1c7e0
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
@@ -0,0 +1,26 @@
+{
+  "description": "Copied unchanged from the released feature flag rules v2 contract in PostHog/posthog-sdk-test-harness. Do not edit these files; copy a newer release instead.",
+  "repository": "https://github.com/PostHog/posthog-sdk-test-harness",
+  "release": "1.22.0",
+  "revision": "17d861f8e230fe943934d70e3eebf5cff6bf3aa4",
+  "contract_directory": "contracts/feature_flag_rules_v2",
+  "contract_version": "7.0.0",
+  "files": {
+    "readers.json": {
+      "source_path": "fixtures/wire/readers.json",
+      "sha256": "fd8edd89f827b732c4659ce7246eab534b0106b96a465a4a2d98cfa0a17d7827"
+    },
+    "responses.json": {
+      "source_path": "fixtures/wire/responses.json",
+      "sha256": "39aa62e340d66903e2fe86da226e622979c7dbc2efbf2b32afd040248a707c61"
+    },
+    "legacy_projection.json": {
+      "source_path": "corpus/legacy_projection.json",
+      "sha256": "536c8386eefa75721d113bd8718ddeb7fb1aad3b4f2cce1fbcf516a346a16e26"
+    },
+    "v2_value_evaluation.json": {
+      "source_path": "corpus/v2_value_evaluation.json",
+      "sha256": "aaddd05e47fc5a4ae07ea42ada5a659798f4b5fc8d0c0827f6a68e4daf68c128"
+    }
+  }
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/legacy_projection.json b/posthog/test/fixtures/feature_flag_rules_v2/legacy_projection.json
new file mode 100644
index 000000000..3a144281c
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/legacy_projection.json
@@ -0,0 +1,661 @@
+{
+  "corpus_version": "1.1.0",
+  "config_version": 1,
+  "description": "Projection matrix from a version 1 evaluation outcome to each response protocol version. Response protocol versions are independent of the config version, which is 1 for every case.",
+  "response_protocols": {
+    "flags_v2": {
+      "endpoint": "/flags",
+      "selected_by": "v=2 or higher, or /decide with v=4 or higher",
+      "shape": "flags map of evaluation details with reason and metadata; errorsWhileComputingFlags at the top level"
+    },
+    "flags_v1": {
+      "endpoint": "/flags",
+      "selected_by": "v=1 or absent, or /decide with v=3",
+      "shape": "featureFlags map of every evaluated flag plus featureFlagPayloads for flags with a payload; errorsWhileComputingFlags at the top level"
+    },
+    "decide_v2": {
+      "endpoint": "/decide",
+      "selected_by": "v=2",
+      "shape": "featureFlags map of enabled flags only"
+    },
+    "decide_v1": {
+      "endpoint": "/decide",
+      "selected_by": "v=1 or absent",
+      "shape": "featureFlags list of enabled flag keys"
+    }
+  },
+  "asserted_fields": "flags_v2 records key, enabled, variant, failed when true, reason.code, reason.condition_index, metadata.id, metadata.version, and metadata.payload. Live responses carry additional request-level and metadata fields that this corpus does not pin.",
+  "cases": [
+    {
+      "id": "projection.boolean_true",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search",
+        "flag_id": 101,
+        "flag_version": 3,
+        "enabled": true,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "condition_match",
+          "condition_index": 0
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "beta-search": {
+              "key": "beta-search",
+              "enabled": true,
+              "variant": null,
+              "reason": {
+                "code": "condition_match",
+                "condition_index": 0
+              },
+              "metadata": {
+                "id": 101,
+                "version": 3,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "beta-search": true
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {
+            "beta-search": true
+          }
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": [
+            "beta-search"
+          ]
+        }
+      }
+    },
+    {
+      "id": "projection.boolean_true_with_payload",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search",
+        "flag_id": 101,
+        "flag_version": 3,
+        "enabled": true,
+        "variant": null,
+        "payload": "{\"cta\":\"Try beta search\"}",
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "condition_match",
+          "condition_index": 0
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "beta-search": {
+              "key": "beta-search",
+              "enabled": true,
+              "variant": null,
+              "reason": {
+                "code": "condition_match",
+                "condition_index": 0
+              },
+              "metadata": {
+                "id": 101,
+                "version": 3,
+                "payload": "{\"cta\":\"Try beta search\"}"
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "beta-search": true
+          },
+          "featureFlagPayloads": {
+            "beta-search": "{\"cta\":\"Try beta search\"}"
+          }
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {
+            "beta-search": true
+          }
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": [
+            "beta-search"
+          ]
+        }
+      },
+      "notes": "The payload is the stored JSON string; no response version parses it."
+    },
+    {
+      "id": "projection.boolean_false_targeting_miss",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search",
+        "flag_id": 101,
+        "flag_version": 3,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "no_condition_match",
+          "condition_index": 0
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "beta-search": {
+              "key": "beta-search",
+              "enabled": false,
+              "variant": null,
+              "reason": {
+                "code": "no_condition_match",
+                "condition_index": 0
+              },
+              "metadata": {
+                "id": 101,
+                "version": 3,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "beta-search": false
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      },
+      "notes": "Every evaluated flag appears in the flags_v1 map, including false results. decide_v2 and decide_v1 carry enabled flags only."
+    },
+    {
+      "id": "projection.boolean_false_out_of_rollout",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search-rollout",
+        "flag_id": 102,
+        "flag_version": 1,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "out_of_rollout_bound",
+          "condition_index": 0
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "beta-search-rollout": {
+              "key": "beta-search-rollout",
+              "enabled": false,
+              "variant": null,
+              "reason": {
+                "code": "out_of_rollout_bound",
+                "condition_index": 0
+              },
+              "metadata": {
+                "id": 102,
+                "version": 1,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "beta-search-rollout": false
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      }
+    },
+    {
+      "id": "projection.variant",
+      "config_version": 1,
+      "outcome": {
+        "key": "checkout-layout",
+        "flag_id": 106,
+        "flag_version": 5,
+        "enabled": true,
+        "variant": "control",
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "condition_match",
+          "condition_index": 1
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "checkout-layout": {
+              "key": "checkout-layout",
+              "enabled": true,
+              "variant": "control",
+              "reason": {
+                "code": "condition_match",
+                "condition_index": 1
+              },
+              "metadata": {
+                "id": 106,
+                "version": 5,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "checkout-layout": "control"
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {
+            "checkout-layout": "control"
+          }
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": [
+            "checkout-layout"
+          ]
+        }
+      },
+      "notes": "A variant projects as its string in every map and as membership in the list."
+    },
+    {
+      "id": "projection.variant_with_payload",
+      "config_version": 1,
+      "outcome": {
+        "key": "checkout-layout",
+        "flag_id": 106,
+        "flag_version": 5,
+        "enabled": true,
+        "variant": "compact",
+        "payload": "{\"density\":\"compact\"}",
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "condition_match",
+          "condition_index": 1
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "checkout-layout": {
+              "key": "checkout-layout",
+              "enabled": true,
+              "variant": "compact",
+              "reason": {
+                "code": "condition_match",
+                "condition_index": 1
+              },
+              "metadata": {
+                "id": 106,
+                "version": 5,
+                "payload": "{\"density\":\"compact\"}"
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "checkout-layout": "compact"
+          },
+          "featureFlagPayloads": {
+            "checkout-layout": "{\"density\":\"compact\"}"
+          }
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {
+            "checkout-layout": "compact"
+          }
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": [
+            "checkout-layout"
+          ]
+        }
+      }
+    },
+    {
+      "id": "projection.holdout_variant",
+      "config_version": 1,
+      "outcome": {
+        "key": "checkout-experiment",
+        "flag_id": 113,
+        "flag_version": 4,
+        "enabled": true,
+        "variant": "holdout-7",
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "holdout_condition_value",
+          "condition_index": null
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "checkout-experiment": {
+              "key": "checkout-experiment",
+              "enabled": true,
+              "variant": "holdout-7",
+              "reason": {
+                "code": "holdout_condition_value",
+                "condition_index": null
+              },
+              "metadata": {
+                "id": 113,
+                "version": 4,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "checkout-experiment": "holdout-7"
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {
+            "checkout-experiment": "holdout-7"
+          }
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": [
+            "checkout-experiment"
+          ]
+        }
+      },
+      "notes": "The synthesized holdout variant projects like any other string value."
+    },
+    {
+      "id": "projection.no_group_type",
+      "config_version": 1,
+      "outcome": {
+        "key": "org-dashboard",
+        "flag_id": 109,
+        "flag_version": 2,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "no_group_type",
+          "condition_index": 0
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "org-dashboard": {
+              "key": "org-dashboard",
+              "enabled": false,
+              "variant": null,
+              "reason": {
+                "code": "no_group_type",
+                "condition_index": 0
+              },
+              "metadata": {
+                "id": 109,
+                "version": 2,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "org-dashboard": false
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      }
+    },
+    {
+      "id": "projection.missing_dependency",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search-suggestions-orphan",
+        "flag_id": 112,
+        "flag_version": 1,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": false,
+        "reason": {
+          "code": "missing_dependency",
+          "condition_index": null
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {
+            "beta-search-suggestions-orphan": {
+              "key": "beta-search-suggestions-orphan",
+              "enabled": false,
+              "variant": null,
+              "reason": {
+                "code": "missing_dependency",
+                "condition_index": null
+              },
+              "metadata": {
+                "id": 112,
+                "version": 1,
+                "payload": null
+              }
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {
+            "beta-search-suggestions-orphan": false
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      },
+      "notes": "A missing dependency is a closed false result, not an evaluation failure, so errorsWhileComputingFlags stays false."
+    },
+    {
+      "id": "projection.failed_evaluation",
+      "config_version": 1,
+      "outcome": {
+        "key": "beta-search",
+        "flag_id": 101,
+        "flag_version": 3,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": true,
+        "omitted": false,
+        "reason": {
+          "code": "timeout",
+          "condition_index": null
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": true,
+          "flags": {
+            "beta-search": {
+              "key": "beta-search",
+              "enabled": false,
+              "variant": null,
+              "reason": {
+                "code": "timeout",
+                "condition_index": null
+              },
+              "metadata": {
+                "id": 101,
+                "version": 3,
+                "payload": null
+              },
+              "failed": true
+            }
+          }
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": true,
+          "featureFlags": {
+            "beta-search": false
+          },
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      },
+      "notes": "A failed evaluation projects as false in the flags_v1 map with errorsWhileComputingFlags true, is omitted from decide_v2 and decide_v1, and carries failed true in flags_v2. The reason code is representative."
+    },
+    {
+      "id": "projection.inactive_omitted",
+      "config_version": 1,
+      "outcome": {
+        "key": "retired-banner",
+        "flag_id": 114,
+        "flag_version": 9,
+        "enabled": false,
+        "variant": null,
+        "payload": null,
+        "failed": false,
+        "omitted": true,
+        "reason": {
+          "code": "no_condition_match",
+          "condition_index": null
+        }
+      },
+      "projections": {
+        "flags_v2": {
+          "response_version": 2,
+          "errorsWhileComputingFlags": false,
+          "flags": {}
+        },
+        "flags_v1": {
+          "response_version": 1,
+          "errorsWhileComputingFlags": false,
+          "featureFlags": {},
+          "featureFlagPayloads": {}
+        },
+        "decide_v2": {
+          "response_version": 2,
+          "featureFlags": {}
+        },
+        "decide_v1": {
+          "response_version": 1,
+          "featureFlags": []
+        }
+      },
+      "notes": "Inactive, archived, and deleted flags are omitted from every response version."
+    }
+  ]
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/readers.json b/posthog/test/fixtures/feature_flag_rules_v2/readers.json
new file mode 100644
index 000000000..7ed8c252b
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/readers.json
@@ -0,0 +1,1078 @@
+{
+  "schema": "schemas/flags_response_v4.schema.json",
+  "templates": {
+    "targeting_match_targeted_release": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "targeting_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "targeted_release",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "targeting_match_percentage_rollout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "targeting_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "percentage_rollout",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "experiment_split": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "rollout_miss_percentage_rollout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "rollout_miss",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "percentage_rollout",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "rollout_miss_experiment": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "rollout_miss",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "experiment_paused": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "experiment_paused",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "holdout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "holdout",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "no_rule_match": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "no_rule_match",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "missing_group_key": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "missing_group_key",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "dependency_error": {
+      "errorsWhileComputingFlags": true,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "dependency_error",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          },
+          "failed": true
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "error": {
+      "errorsWhileComputingFlags": true,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "error",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          },
+          "failed": true
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "v1": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": "compact",
+          "reason": {
+            "code": "condition_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 202,
+            "version": 9,
+            "config_version": 1,
+            "has_experiment": false,
+            "variant_key": "compact",
+            "payload": "{\"columns\":2}"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "omitted": {
+      "errorsWhileComputingFlags": false,
+      "flags": {},
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "old_server": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "enabled": true,
+          "variant": "compact",
+          "reason": {
+            "code": "condition_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 202,
+            "version": 9,
+            "config_version": 2,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    }
+  },
+  "cases": [
+    {
+      "id": "readers.complete_split",
+      "template": "experiment_split",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.partial_split_missing_config_version",
+      "template": "experiment_split",
+      "remove": [
+        "/flags/garden-layout/metadata/config_version"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "config_version"
+      },
+      "producer_expected": "invalid"
+    },
+    {
+      "id": "readers.partial_split_missing_rule_type",
+      "template": "experiment_split",
+      "remove": [
+        "/flags/garden-layout/metadata/rule_type"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "rule_type"
+      },
+      "producer_expected": "invalid"
+    },
+    {
+      "id": "readers.partial_split_missing_rule_id",
+      "template": "experiment_split",
+      "remove": [
+        "/flags/garden-layout/metadata/rule_id"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "rule_id"
+      },
+      "producer_expected": "invalid"
+    },
+    {
+      "id": "readers.partial_split_missing_variant_key",
+      "template": "experiment_split",
+      "remove": [
+        "/flags/garden-layout/metadata/variant_key"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "variant_key"
+      },
+      "producer_expected": "invalid"
+    },
+    {
+      "id": "readers.split_wrong_type_config_version",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/config_version": "2"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "PARSE_ERROR"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "enum",
+        "instance_path": "/flags/garden-layout/metadata/config_version"
+      }
+    },
+    {
+      "id": "readers.split_wrong_type_rule_type",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": 2
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "PARSE_ERROR"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "enum",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "readers.split_wrong_type_rule_id",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_id": 3
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "PARSE_ERROR"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/rule_id"
+      }
+    },
+    {
+      "id": "readers.split_wrong_type_experiment_id",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/experiment_id": "301"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "PARSE_ERROR"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/experiment_id"
+      }
+    },
+    {
+      "id": "readers.split_extra_experiment_id",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/experiment_id": 301
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "readers.split_wrong_type_variant_key",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/variant_key": true
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "PARSE_ERROR"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/variant_key"
+      }
+    },
+    {
+      "id": "readers.wrong_rule_type_literal",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "percentage_rollout"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "readers.unknown_fields",
+      "template": "experiment_split",
+      "set": {
+        "/future_envelope": {
+          "nested": true
+        },
+        "/flags/garden-layout/future_record": [],
+        "/flags/garden-layout/reason/future_reason": 3,
+        "/flags/garden-layout/metadata/future_metadata": "ignored"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "additionalProperties",
+        "instance_path": "/flags/garden-layout"
+      }
+    },
+    {
+      "id": "readers.old_server_variant",
+      "template": "old_server",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": "compact",
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "value"
+      }
+    },
+    {
+      "id": "readers.old_server_boolean",
+      "template": "old_server",
+      "remove": [
+        "/flags/garden-layout/variant"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": true,
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "value"
+      }
+    },
+    {
+      "id": "readers.old_server_null_variant",
+      "template": "old_server",
+      "set": {
+        "/flags/garden-layout/variant": null
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": true,
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "value"
+      }
+    },
+    {
+      "id": "readers.old_server_false",
+      "template": "old_server",
+      "set": {
+        "/flags/garden-layout/enabled": false
+      },
+      "remove": [
+        "/flags/garden-layout/variant"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "value"
+      }
+    },
+    {
+      "id": "readers.v4_value_takes_precedence",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/enabled": true,
+        "/flags/garden-layout/variant": "wrong-channel"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "additionalProperties",
+        "instance_path": "/flags/garden-layout"
+      }
+    },
+    {
+      "id": "readers.missing_flag",
+      "template": "omitted",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": null,
+        "experiment_exposure": false,
+        "error_code": "FLAG_NOT_FOUND"
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.targeting_match_targeted_release",
+      "template": "targeting_match_targeted_release",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.targeting_match_percentage_rollout",
+      "template": "targeting_match_percentage_rollout",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.rollout_miss_percentage_rollout",
+      "template": "rollout_miss_percentage_rollout",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.rollout_miss_experiment",
+      "template": "rollout_miss_experiment",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.experiment_paused",
+      "template": "experiment_paused",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.holdout",
+      "template": "holdout",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.holdout_variant_key",
+      "template": "holdout",
+      "set": {
+        "/flags/garden-layout/metadata/variant_key": "arm_a"
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "presence",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "readers.no_rule_match",
+      "template": "no_rule_match",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.missing_group_key",
+      "template": "missing_group_key",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": "INVALID_CONTEXT"
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.dependency_error",
+      "template": "dependency_error",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": "GENERAL"
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.error",
+      "template": "error",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": "GENERAL"
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.error_with_value",
+      "template": "error",
+      "set": {
+        "/flags/garden-layout/value": false
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": "GENERAL"
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "readers.malformed_sibling_isolation",
+      "template": "experiment_split",
+      "set": {
+        "/flags/sibling": {
+          "key": "sibling",
+          "value": [],
+          "reason": {
+            "code": "no_rule_match",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 203,
+            "version": 1,
+            "config_version": 2,
+            "has_experiment": false
+          }
+        }
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "sibling_expectations": {
+        "sibling": {
+          "error_code": "PARSE_ERROR",
+          "experiment_exposure": false
+        }
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/sibling/value"
+      }
+    },
+    {
+      "id": "readers.partial_split_string_value",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/value": "usable-copy"
+      },
+      "remove": [
+        "/flags/garden-layout/metadata/variant_key"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": "usable-copy",
+        "config_version": 2,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "invalid",
+      "producer_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "variant_key"
+      }
+    },
+    {
+      "id": "readers.v1_at_v4",
+      "template": "v1",
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": false,
+        "value": "compact",
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.v1_failed",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/flags/garden-layout/reason": {
+          "code": "missing_dependency",
+          "condition_index": null
+        },
+        "/errorsWhileComputingFlags": true
+      },
+      "remove": [
+        "/flags/garden-layout/metadata/variant_key"
+      ],
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": true,
+        "config_version": 1,
+        "experiment_exposure": false,
+        "error_code": "GENERAL"
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.integral_json_number_context",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/config_version": 2.0,
+        "/flags/garden-layout/metadata/id": 201.0
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "garden-layout",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    },
+    {
+      "id": "readers.flag_key_seed",
+      "template": "omitted",
+      "set": {
+        "/flags/seed": {
+          "key": "seed",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "expected": "reader",
+      "reader": {
+        "requested_key": "seed",
+        "caller_default": true,
+        "value": false,
+        "config_version": 2,
+        "experiment_exposure": true,
+        "error_code": null
+      },
+      "producer_expected": "valid"
+    }
+  ]
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/responses.json b/posthog/test/fixtures/feature_flag_rules_v2/responses.json
new file mode 100644
index 000000000..1d1c60969
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/responses.json
@@ -0,0 +1,1151 @@
+{
+  "schema": "schemas/flags_response_v4.schema.json",
+  "templates": {
+    "targeting_match_targeted_release": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "targeting_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "targeted_release",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "targeting_match_percentage_rollout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "targeting_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "percentage_rollout",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "experiment_split": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "rollout_miss_percentage_rollout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "rollout_miss",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null,
+            "rule_type": "percentage_rollout",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "rollout_miss_experiment": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "rollout_miss",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "experiment_paused": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "experiment_paused",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "holdout": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "holdout",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "no_rule_match": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": false,
+          "reason": {
+            "code": "no_rule_match",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "missing_group_key": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "missing_group_key",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "dependency_error": {
+      "errorsWhileComputingFlags": true,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "dependency_error",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          },
+          "failed": true
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "error": {
+      "errorsWhileComputingFlags": true,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": null,
+          "reason": {
+            "code": "error",
+            "condition_index": null
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": false,
+            "payload": null
+          },
+          "failed": true
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "v1": {
+      "errorsWhileComputingFlags": false,
+      "flags": {
+        "garden-layout": {
+          "key": "garden-layout",
+          "value": "compact",
+          "reason": {
+            "code": "condition_match",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 202,
+            "version": 9,
+            "config_version": 1,
+            "has_experiment": false,
+            "variant_key": "compact",
+            "payload": "{\"columns\":2}"
+          }
+        }
+      },
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    },
+    "omitted": {
+      "errorsWhileComputingFlags": false,
+      "flags": {},
+      "requestId": "20000000-0000-4000-8000-000000000002",
+      "evaluatedAt": 1800000000000
+    }
+  },
+  "cases": [
+    {
+      "id": "responses.targeting_match_targeted_release",
+      "template": "targeting_match_targeted_release",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.missing_id",
+      "template": "targeting_match_targeted_release",
+      "remove": [
+        "/flags/garden-layout/metadata/id"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "id"
+      }
+    },
+    {
+      "id": "responses.missing_version",
+      "template": "targeting_match_targeted_release",
+      "remove": [
+        "/flags/garden-layout/metadata/version"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "version"
+      }
+    },
+    {
+      "id": "responses.missing_config_version",
+      "template": "targeting_match_targeted_release",
+      "remove": [
+        "/flags/garden-layout/metadata/config_version"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "config_version"
+      }
+    },
+    {
+      "id": "responses.targeting_match_targeted_release_forbidden_failed",
+      "template": "targeting_match_targeted_release",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.targeting_match_targeted_release_flag_with_experiment",
+      "template": "targeting_match_targeted_release",
+      "set": {
+        "/flags/garden-layout/metadata/has_experiment": true
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.targeting_match_percentage_rollout",
+      "template": "targeting_match_percentage_rollout",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.targeting_match_percentage_rollout_forbidden_failed",
+      "template": "targeting_match_percentage_rollout",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.experiment_split",
+      "template": "experiment_split",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.experiment_split_forbidden_failed",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.experiment_split_flag_without_experiment",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/has_experiment": false
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.rollout_miss_percentage_rollout",
+      "template": "rollout_miss_percentage_rollout",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.rollout_miss_percentage_rollout_forbidden_failed",
+      "template": "rollout_miss_percentage_rollout",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.rollout_miss_experiment",
+      "template": "rollout_miss_experiment",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.rollout_miss_experiment_forbidden_failed",
+      "template": "rollout_miss_experiment",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.experiment_paused",
+      "template": "experiment_paused",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.experiment_paused_forbidden_failed",
+      "template": "experiment_paused",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.holdout",
+      "template": "holdout",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.holdout_missing_rule_id",
+      "template": "holdout",
+      "remove": [
+        "/flags/garden-layout/metadata/rule_id"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout/metadata",
+        "message_contains": "rule_id"
+      }
+    },
+    {
+      "id": "responses.holdout_forbidden_failed",
+      "template": "holdout",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.no_rule_match",
+      "template": "no_rule_match",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.no_rule_match_forbidden_failed",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout"
+      }
+    },
+    {
+      "id": "responses.missing_group_key",
+      "template": "missing_group_key",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.missing_group_key_forbidden_failed",
+      "template": "missing_group_key",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout"
+      }
+    },
+    {
+      "id": "responses.dependency_error",
+      "template": "dependency_error",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.dependency_error_missing_failed",
+      "template": "dependency_error",
+      "remove": [
+        "/flags/garden-layout/failed"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "failed"
+      }
+    },
+    {
+      "id": "responses.dependency_error_nonnull_value",
+      "template": "dependency_error",
+      "set": {
+        "/flags/garden-layout/value": false
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.error",
+      "template": "error",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.error_missing_failed",
+      "template": "error",
+      "remove": [
+        "/flags/garden-layout/failed"
+      ],
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "required",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "failed"
+      }
+    },
+    {
+      "id": "responses.error_nonnull_value",
+      "template": "error",
+      "set": {
+        "/flags/garden-layout/value": false
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.v1",
+      "template": "v1",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.omitted",
+      "template": "omitted",
+      "expected": "valid"
+    },
+    {
+      "id": "responses.split_wrong_type_config_version",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/config_version": "2"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "enum",
+        "instance_path": "/flags/garden-layout/metadata/config_version"
+      }
+    },
+    {
+      "id": "responses.split_wrong_type_rule_type",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": 2
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "enum",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "responses.split_wrong_type_rule_id",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_id": 3
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/rule_id"
+      }
+    },
+    {
+      "id": "responses.split_wrong_type_variant_key",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/variant_key": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/variant_key"
+      }
+    },
+    {
+      "id": "responses.forbidden_legacy_enabled",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/enabled": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "additionalProperties",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "enabled"
+      }
+    },
+    {
+      "id": "responses.forbidden_legacy_variant",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/variant": "arm_a"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "additionalProperties",
+        "instance_path": "/flags/garden-layout",
+        "message_contains": "variant"
+      }
+    },
+    {
+      "id": "responses.split_arm_b_equal_value",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/variant_key": "arm_b"
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.split_string_value",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/value": "same-copy"
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.null_default",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/value": null
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.request_failure_omission",
+      "template": "omitted",
+      "set": {
+        "/errorsWhileComputingFlags": true
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.missing_group_nonnull_value",
+      "template": "missing_group_key",
+      "set": {
+        "/flags/garden-layout/value": false
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.v1_failed",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/failed": true,
+        "/flags/garden-layout/value": null,
+        "/flags/garden-layout/reason": {
+          "code": "missing_dependency",
+          "condition_index": null
+        },
+        "/errorsWhileComputingFlags": true
+      },
+      "remove": [
+        "/flags/garden-layout/metadata/variant_key"
+      ],
+      "expected": "valid"
+    },
+    {
+      "id": "responses.v1_quick_win",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/experiment_id": 301,
+        "/flags/garden-layout/metadata/forced_variant": true,
+        "/flags/garden-layout/metadata/has_experiment": true
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.v2_forced_variant",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/forced_variant": true
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.key_mismatch",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/key": "different-key"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "semantic",
+        "keyword": "map_key",
+        "instance_path": "/flags/garden-layout/key"
+      }
+    },
+    {
+      "id": "responses.failure_envelope",
+      "template": "error",
+      "set": {
+        "/errorsWhileComputingFlags": false
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "const",
+        "instance_path": "/errorsWhileComputingFlags"
+      }
+    },
+    {
+      "id": "responses.local_only_reason",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/reason/code": "flag_disabled"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "enum",
+        "instance_path": "/flags/garden-layout/reason/code"
+      }
+    },
+    {
+      "id": "responses.nested_seed",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/conditions": [
+          {
+            "nested": [
+              {
+                "seed": "invented-assignment"
+              }
+            ]
+          }
+        ]
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "seed",
+        "keyword": "assignment_seed",
+        "instance_path": "/flags/garden-layout/conditions/0/nested/0/seed"
+      }
+    },
+    {
+      "id": "responses.passthrough_seed",
+      "template": "omitted",
+      "set": {
+        "/future": {
+          "items": [
+            {
+              "holdout_seed": "invented-holdout"
+            }
+          ]
+        }
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "seed",
+        "keyword": "assignment_seed",
+        "instance_path": "/future/items/0/holdout_seed"
+      }
+    },
+    {
+      "id": "responses.reserved_number_wire_value",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/value": 7
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.reserved_object_wire_value",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/value": {
+          "layout": "compact"
+        }
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.targeting_match_targeted_release_wrong_rule_type",
+      "template": "targeting_match_targeted_release",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "experiment"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "responses.experiment_split_wrong_rule_type",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "percentage_rollout"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "schema",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "responses.experiment_paused_wrong_rule_type",
+      "template": "experiment_paused",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "percentage_rollout"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "responses.holdout_wrong_rule_type",
+      "template": "holdout",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "percentage_rollout"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/rule_type"
+      }
+    },
+    {
+      "id": "responses.targeting_match_targeted_release_null_value",
+      "template": "targeting_match_targeted_release",
+      "set": {
+        "/flags/garden-layout/value": null
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.targeting_match_percentage_rollout_null_value",
+      "template": "targeting_match_percentage_rollout",
+      "set": {
+        "/flags/garden-layout/value": null
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.experiment_split_null_value",
+      "template": "experiment_split",
+      "set": {
+        "/flags/garden-layout/value": null
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.empty_v2_string",
+      "template": "no_rule_match",
+      "set": {
+        "/flags/garden-layout/value": ""
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "minLength",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    },
+    {
+      "id": "responses.v1_experiment_without_linkage",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/experiment_id": 301
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "const",
+        "instance_path": "/flags/garden-layout/metadata/has_experiment"
+      }
+    },
+    {
+      "id": "responses.v1_ambiguous_experiment",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/has_experiment": true
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.flag_key_seed",
+      "template": "omitted",
+      "set": {
+        "/flags/seed": {
+          "key": "seed",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.seed_named_flag_nested_seed",
+      "template": "omitted",
+      "set": {
+        "/flags/seed": {
+          "key": "seed",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          },
+          "conditions": [
+            {
+              "nested": [
+                {
+                  "seed": "invented-assignment"
+                }
+              ]
+            }
+          ]
+        }
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "seed",
+        "keyword": "assignment_seed",
+        "instance_path": "/flags/seed/conditions/0/nested/0/seed"
+      }
+    },
+    {
+      "id": "responses.flag_key_assignment_seed",
+      "template": "omitted",
+      "set": {
+        "/flags/assignment_seed": {
+          "key": "assignment_seed",
+          "value": false,
+          "reason": {
+            "code": "experiment_split",
+            "condition_index": 0
+          },
+          "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": true,
+            "payload": null,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "arm_a"
+          }
+        }
+      },
+      "expected": "valid"
+    },
+    {
+      "id": "responses.v1_forbidden_rule_id",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/rule_id": "10000000-0000-4000-8000-000000000001"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.v1_forbidden_rule_type",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/rule_type": "targeted_release"
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "not",
+        "instance_path": "/flags/garden-layout/metadata"
+      }
+    },
+    {
+      "id": "responses.v1_object_payload",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/metadata/payload": {
+          "columns": 2
+        }
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/metadata/payload"
+      }
+    },
+    {
+      "id": "responses.v1_null_value_not_failed",
+      "template": "v1",
+      "set": {
+        "/flags/garden-layout/value": null
+      },
+      "expected": "invalid",
+      "expected_failure": {
+        "layer": "presence",
+        "keyword": "type",
+        "instance_path": "/flags/garden-layout/value"
+      }
+    }
+  ]
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/v2_value_evaluation.json b/posthog/test/fixtures/feature_flag_rules_v2/v2_value_evaluation.json
new file mode 100644
index 000000000..c48e40782
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/v2_value_evaluation.json
@@ -0,0 +1,3080 @@
+{
+  "corpus_version": "1.0.0",
+  "config_version": 2,
+  "description": "Person string, number and object ordered evaluation with the legacy rendering of each result. Expected terminal fields and legacy cells are exhaustive. Parser rows run at the parser boundary.",
+  "cases": [
+    {
+      "id": "v2_value.string.target",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "compact",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "compact",
+        "value": "compact",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.rollout_hit",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact",
+            "rollout_percentage": 100,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "compact",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "compact",
+        "value": "compact",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.miss_return_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact",
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "wide"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "standard",
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "standard",
+        "value": "standard",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.miss_return_default_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact",
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "wide"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.miss_continue",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact",
+            "rollout_percentage": 0,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "wide"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "wide",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "wide",
+        "value": "wide",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.no_match_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": "compact"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "standard",
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "standard",
+        "value": "standard",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.no_match_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": "compact"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.order_first_match",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": "compact"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "wide"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "compact",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "compact",
+        "value": "compact",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.order_targeting_miss",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": "compact"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": "wide"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "wide",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "wide",
+        "value": "wide",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.number.target",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 1.25,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 1.25
+      }
+    },
+    {
+      "id": "v2_value.number.rollout_hit",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25,
+            "rollout_percentage": 100,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 1.25,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 1.25
+      }
+    },
+    {
+      "id": "v2_value.number.miss_return_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25,
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -40
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 0,
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 0
+      }
+    },
+    {
+      "id": "v2_value.number.miss_return_default_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25,
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -40
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.number.miss_continue",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25,
+            "rollout_percentage": 0,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -40
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": -40,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": -40
+      }
+    },
+    {
+      "id": "v2_value.number.no_match_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": 1.25
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 0,
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 0
+      }
+    },
+    {
+      "id": "v2_value.number.no_match_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": 1.25
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.number.order_first_match",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": 1.25
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -40
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 1.25,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 1.25
+      }
+    },
+    {
+      "id": "v2_value.number.order_targeting_miss",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": 1.25
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": -40
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": -40,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": -40
+      }
+    },
+    {
+      "id": "v2_value.object.target",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.rollout_hit",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            },
+            "rollout_percentage": 100,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.miss_return_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            },
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "wide"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "standard"
+        },
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "standard"
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.miss_return_default_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            },
+            "rollout_percentage": 0,
+            "on_rollout_miss": "return_default",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "wide"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "rollout_miss",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "percentage_rollout",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.object.miss_continue",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "percentage_rollout",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            },
+            "rollout_percentage": 0,
+            "on_rollout_miss": "continue",
+            "assignment_algorithm": "sha1_60_v1",
+            "seed": "example-allocation",
+            "assign_by": "person"
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "wide"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "wide"
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "wide"
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.no_match_default",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "standard"
+        },
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "standard"
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.no_match_null",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": null,
+        "reason": "no_rule_match"
+      },
+      "legacy": {
+        "enabled": false,
+        "variant": null,
+        "value": false,
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.object.order_first_match",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            }
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "wide"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "compact",
+          "options": [
+            1,
+            true,
+            null
+          ]
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.order_targeting_miss",
+      "family": "ordering",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": {
+          "layout": "standard"
+        },
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "free"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": {
+              "layout": "compact",
+              "options": [
+                1,
+                true,
+                null
+              ]
+            }
+          },
+          {
+            "id": "22222222-2222-4222-8222-222222222222",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": [
+                {
+                  "key": "plan",
+                  "type": "person",
+                  "operator": "exact",
+                  "value": [
+                    "pro"
+                  ],
+                  "negation": false
+                }
+              ]
+            },
+            "value": {
+              "layout": "wide"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "layout": "wide"
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "22222222-2222-4222-8222-222222222222",
+          "rule_type": "targeted_release",
+          "index": 1
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "layout": "wide"
+        }
+      }
+    },
+    {
+      "id": "v2_value.string.unicode",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "Grüße 👋"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "Grüße 👋",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "Grüße 👋",
+        "value": "Grüße 👋",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.string.looks_boolean",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "false"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": "false",
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": "false",
+        "value": "false",
+        "payload": null
+      }
+    },
+    {
+      "id": "v2_value.number.zero",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 0
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 0,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 0
+      }
+    },
+    {
+      "id": "v2_value.number.negative_decimal",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -2.5
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": -2.5,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": -2.5
+      }
+    },
+    {
+      "id": "v2_value.number.short_decimal",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 0.1
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 0.1,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 0.1
+      }
+    },
+    {
+      "id": "v2_value.number.exponent",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.5e-07
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 1.5e-07,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 1.5e-07
+      }
+    },
+    {
+      "id": "v2_value.number.max_safe_integer",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 9007199254740991
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": 9007199254740991,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": 9007199254740991
+      }
+    },
+    {
+      "id": "v2_value.number.min_safe_integer",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -9007199254740991
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": -9007199254740991,
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": -9007199254740991
+      }
+    },
+    {
+      "id": "v2_value.object.empty",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {}
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {},
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {}
+      }
+    },
+    {
+      "id": "v2_value.object.nested",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "theme": {
+                "colors": [
+                  "#000000",
+                  "#ffffff"
+                ],
+                "radius": 4.5
+              },
+              "flags": [
+                true,
+                false,
+                null
+              ],
+              "label": "Ünïcode"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "theme": {
+            "colors": [
+              "#000000",
+              "#ffffff"
+            ],
+            "radius": 4.5
+          },
+          "flags": [
+            true,
+            false,
+            null
+          ],
+          "label": "Ünïcode"
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "theme": {
+            "colors": [
+              "#000000",
+              "#ffffff"
+            ],
+            "radius": 4.5
+          },
+          "flags": [
+            true,
+            false,
+            null
+          ],
+          "label": "Ünïcode"
+        }
+      }
+    },
+    {
+      "id": "v2_value.object.max_depth",
+      "family": "values",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "child": {
+                "child": {
+                  "child": {
+                    "child": {
+                      "child": {
+                        "child": {
+                          "child": {
+                            "child": {
+                              "child": {
+                                "child": {
+                                  "child": {
+                                    "child": {
+                                      "child": {
+                                        "child": {
+                                          "child": {
+                                            "child": {
+                                              "child": {
+                                                "child": {
+                                                  "child": {
+                                                    "leaf": true
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "success",
+        "value": {
+          "child": {
+            "child": {
+              "child": {
+                "child": {
+                  "child": {
+                    "child": {
+                      "child": {
+                        "child": {
+                          "child": {
+                            "child": {
+                              "child": {
+                                "child": {
+                                  "child": {
+                                    "child": {
+                                      "child": {
+                                        "child": {
+                                          "child": {
+                                            "child": {
+                                              "child": {
+                                                "leaf": true
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "reason": "targeting_match",
+        "rule": {
+          "id": "11111111-1111-4111-8111-111111111111",
+          "rule_type": "targeted_release",
+          "index": 0
+        }
+      },
+      "legacy": {
+        "enabled": true,
+        "variant": null,
+        "value": true,
+        "payload": {
+          "child": {
+            "child": {
+              "child": {
+                "child": {
+                  "child": {
+                    "child": {
+                      "child": {
+                        "child": {
+                          "child": {
+                            "child": {
+                              "child": {
+                                "child": {
+                                  "child": {
+                                    "child": {
+                                      "child": {
+                                        "child": {
+                                          "child": {
+                                            "child": {
+                                              "child": {
+                                                "leaf": true
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    {
+      "id": "v2_value.parser.string_empty_value",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": ""
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.string_empty_default",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "compact"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.string_value_mismatch",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "string",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": true
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.number_value_mismatch",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": "1.25"
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.number_default_mismatch",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": true,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 1.25
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.number_above_safe_integer",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": 9007199254740992.0
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.number_below_safe_integer",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "number",
+        "default_value": 0,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": -9007199254740992.0
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.object_array_value",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": [
+              {
+                "layout": "compact"
+              }
+            ]
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.object_default_mismatch",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": "standard",
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "layout": "compact"
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.object_too_deep",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "child": {
+                "child": {
+                  "child": {
+                    "child": {
+                      "child": {
+                        "child": {
+                          "child": {
+                            "child": {
+                              "child": {
+                                "child": {
+                                  "child": {
+                                    "child": {
+                                      "child": {
+                                        "child": {
+                                          "child": {
+                                            "child": {
+                                              "child": {
+                                                "child": {
+                                                  "child": {
+                                                    "child": {
+                                                      "leaf": true
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    },
+    {
+      "id": "v2_value.parser.object_nested_number_above_safe_integer",
+      "family": "parser",
+      "flag": {
+        "key": "example-display-key",
+        "name": "Example display name",
+        "active": true,
+        "deleted": false,
+        "requested": true
+      },
+      "config": {
+        "version": 2,
+        "return_type": "object",
+        "default_value": null,
+        "rules": [
+          {
+            "id": "11111111-1111-4111-8111-111111111111",
+            "rule_type": "targeted_release",
+            "targeting": {
+              "properties": []
+            },
+            "value": {
+              "limit": 9007199254740992.0
+            }
+          }
+        ]
+      },
+      "context": {
+        "identifier": "person-example",
+        "properties": {
+          "plan": "pro"
+        },
+        "properties_complete": true,
+        "timezone": "UTC",
+        "explicit_exact_matching": true,
+        "now": "2024-03-31T12:00:00Z"
+      },
+      "expected": {
+        "status": "parse_error",
+        "kind": "malformed"
+      }
+    }
+  ]
+}
diff --git a/posthog/test/fixtures/released_flags_7_82_1.json b/posthog/test/fixtures/released_flags_7_82_1.json
new file mode 100644
index 000000000..627f5336e
--- /dev/null
+++ b/posthog/test/fixtures/released_flags_7_82_1.json
@@ -0,0 +1,2258 @@
+{
+  "description": "Results of the scenarios in posthog/test/released_flags_scenarios.py, recorded with posthog 7.82.1 from the v2 response shape. See that module to regenerate.",
+  "results": {
+    "cache histories": {
+      "good, disabled, timeout": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": false,
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": false,
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": false,
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_response": false,
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            false,
+            null,
+            null,
+            "Matched condition set 1"
+          ],
+          [
+            false,
+            null,
+            null,
+            "Matched condition set 1"
+          ]
+        ]
+      },
+      "good, each request failure": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "connection_error",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "api_error_500",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "quota_limited",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "unknown_error",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ]
+        ]
+      },
+      "good, missing with errors, timeout": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": null,
+              "$feature_flag": "cached",
+              "$feature_flag_error": "errors_while_computing_flags,flag_missing",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": null,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          null,
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ]
+        ]
+      },
+      "good, other variant, timeout": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "green",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "green",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "green",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_response": "green",
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "green",
+            null,
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "green",
+            null,
+            "Matched condition set 1"
+          ]
+        ]
+      },
+      "good, server failed, timeout": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": false,
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": false,
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": false,
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": false,
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            false,
+            null,
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            false,
+            null,
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ]
+        ]
+      },
+      "good, unreadable record, timeout": {
+        "events": [
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_evaluated_at": 1800000000000,
+              "$feature_flag_has_experiment": false,
+              "$feature_flag_id": 700,
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_reason": "Matched condition set 1",
+              "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+              "$feature_flag_response": "blue",
+              "$feature_flag_version": 3,
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "unknown_error",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ],
+          [
+            "$feature_flag_called",
+            {
+              "$feature/cached": "blue",
+              "$feature_flag": "cached",
+              "$feature_flag_error": "timeout",
+              "$feature_flag_payload": {
+                "theme": "dark"
+              },
+              "$feature_flag_response": "blue",
+              "locally_evaluated": false
+            }
+          ]
+        ],
+        "results": [
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ],
+          [
+            true,
+            "blue",
+            {
+              "theme": "dark"
+            },
+            "Matched condition set 1"
+          ]
+        ]
+      }
+    },
+    "getters": {
+      "events": [
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-on": true,
+            "$feature_flag": "bool-on",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-on": true,
+            "$feature_flag": "bool-on",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-on": true,
+            "$feature_flag": "bool-on",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-off": false,
+            "$feature_flag": "bool-off",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-off": false,
+            "$feature_flag": "bool-off",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-off": false,
+            "$feature_flag": "bool-off",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-bool-payload": true,
+            "$feature_flag": "v1-bool-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "cta": "Try it",
+              "n": 1
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-bool-payload": true,
+            "$feature_flag": "v1-bool-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "cta": "Try it",
+              "n": 1
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-bool-payload": true,
+            "$feature_flag": "v1-bool-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "cta": "Try it",
+              "n": 1
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-string-payload": true,
+            "$feature_flag": "v1-string-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": "plain",
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-string-payload": true,
+            "$feature_flag": "v1-string-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": "plain",
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-string-payload": true,
+            "$feature_flag": "v1-string-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": "plain",
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-string": "compact",
+            "$feature_flag": "v2-string",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-string": "compact",
+            "$feature_flag": "v2-string",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-string": "compact",
+            "$feature_flag": "v2-string",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-null": false,
+            "$feature_flag": "v2-null",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-null": false,
+            "$feature_flag": "v2-null",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-null": false,
+            "$feature_flag": "v2-null",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-number": true,
+            "$feature_flag": "v2-number",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": 12.5,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-number": true,
+            "$feature_flag": "v2-number",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": 12.5,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-number": true,
+            "$feature_flag": "v2-number",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": 12.5,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-object": true,
+            "$feature_flag": "v2-object",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "layout": "compact",
+              "n": [
+                1,
+                true
+              ]
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-object": true,
+            "$feature_flag": "v2-object",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "layout": "compact",
+              "n": [
+                1,
+                true
+              ]
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-object": true,
+            "$feature_flag": "v2-object",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "layout": "compact",
+              "n": [
+                1,
+                true
+              ]
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/sparse": "compact",
+            "$feature_flag": "sparse",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/sparse": "compact",
+            "$feature_flag": "sparse",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/sparse": "compact",
+            "$feature_flag": "sparse",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/server-failed": false,
+            "$feature_flag": "server-failed",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/server-failed": false,
+            "$feature_flag": "server-failed",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/server-failed": false,
+            "$feature_flag": "server-failed",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-on": true,
+            "$feature_flag": "bool-on",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/bool-off": false,
+            "$feature_flag": "bool-off",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-bool-payload": true,
+            "$feature_flag": "v1-bool-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "cta": "Try it",
+              "n": 1
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-string-payload": true,
+            "$feature_flag": "v1-string-payload",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": "plain",
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-string": "compact",
+            "$feature_flag": "v2-string",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-null": false,
+            "$feature_flag": "v2-null",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-number": true,
+            "$feature_flag": "v2-number",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": 12.5,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v2-object": true,
+            "$feature_flag": "v2-object",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "layout": "compact",
+              "n": [
+                1,
+                true
+              ]
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": true,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/sparse": "compact",
+            "$feature_flag": "sparse",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "compact",
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/server-failed": false,
+            "$feature_flag": "server-failed",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": false,
+            "$feature_flag_id": 700,
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "$feature_flag_version": 3,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "snapshot-event",
+          {
+            "$active_feature_flags": [
+              "bool-on",
+              "sparse",
+              "v1-bool-payload",
+              "v1-string-payload",
+              "v1-variant",
+              "v2-number",
+              "v2-object",
+              "v2-string"
+            ],
+            "$feature/bool-off": false,
+            "$feature/bool-on": true,
+            "$feature/server-failed": false,
+            "$feature/sparse": "compact",
+            "$feature/v1-bool-payload": true,
+            "$feature/v1-string-payload": true,
+            "$feature/v1-variant": "control",
+            "$feature/v2-null": false,
+            "$feature/v2-number": true,
+            "$feature/v2-object": true,
+            "$feature/v2-string": "compact"
+          }
+        ],
+        [
+          "fetched-event",
+          {
+            "$active_feature_flags": [
+              "bool-on",
+              "v1-variant",
+              "v1-bool-payload",
+              "v1-string-payload",
+              "v2-string",
+              "v2-number",
+              "v2-object",
+              "sparse"
+            ],
+            "$feature/bool-off": false,
+            "$feature/bool-on": true,
+            "$feature/server-failed": false,
+            "$feature/sparse": "compact",
+            "$feature/v1-bool-payload": true,
+            "$feature/v1-string-payload": true,
+            "$feature/v1-variant": "control",
+            "$feature/v2-null": false,
+            "$feature/v2-number": true,
+            "$feature/v2-object": true,
+            "$feature/v2-string": "compact"
+          }
+        ]
+      ],
+      "feature_enabled:bool-off": false,
+      "feature_enabled:bool-on": true,
+      "feature_enabled:missing": null,
+      "feature_enabled:server-failed": false,
+      "feature_enabled:sparse": true,
+      "feature_enabled:v1-bool-payload": true,
+      "feature_enabled:v1-string-payload": true,
+      "feature_enabled:v1-variant": true,
+      "feature_enabled:v2-null": false,
+      "feature_enabled:v2-number": true,
+      "feature_enabled:v2-object": true,
+      "feature_enabled:v2-string": true,
+      "get_all_flags": {
+        "bool-off": false,
+        "bool-on": true,
+        "server-failed": false,
+        "sparse": "compact",
+        "v1-bool-payload": true,
+        "v1-string-payload": true,
+        "v1-variant": "control",
+        "v2-null": false,
+        "v2-number": true,
+        "v2-object": true,
+        "v2-string": "compact"
+      },
+      "get_all_flags_and_payloads": {
+        "featureFlagPayloads": {
+          "v1-bool-payload": "{\"cta\": \"Try it\", \"n\": 1}",
+          "v1-string-payload": "\"plain\"",
+          "v1-variant": "{\"columns\": 2}",
+          "v2-number": "12.5",
+          "v2-object": "{\"layout\":\"compact\",\"n\":[1,true]}"
+        },
+        "featureFlags": {
+          "bool-off": false,
+          "bool-on": true,
+          "server-failed": false,
+          "sparse": "compact",
+          "v1-bool-payload": true,
+          "v1-string-payload": true,
+          "v1-variant": "control",
+          "v2-null": false,
+          "v2-number": true,
+          "v2-object": true,
+          "v2-string": "compact"
+        }
+      },
+      "get_feature_flag:bool-off": false,
+      "get_feature_flag:bool-on": true,
+      "get_feature_flag:missing": null,
+      "get_feature_flag:server-failed": false,
+      "get_feature_flag:sparse": "compact",
+      "get_feature_flag:v1-bool-payload": true,
+      "get_feature_flag:v1-string-payload": true,
+      "get_feature_flag:v1-variant": "control",
+      "get_feature_flag:v2-null": false,
+      "get_feature_flag:v2-number": true,
+      "get_feature_flag:v2-object": true,
+      "get_feature_flag:v2-string": "compact",
+      "get_feature_flag_payload:bool-off": null,
+      "get_feature_flag_payload:bool-on": null,
+      "get_feature_flag_payload:missing": null,
+      "get_feature_flag_payload:server-failed": null,
+      "get_feature_flag_payload:sparse": null,
+      "get_feature_flag_payload:v1-bool-payload": {
+        "cta": "Try it",
+        "n": 1
+      },
+      "get_feature_flag_payload:v1-string-payload": "plain",
+      "get_feature_flag_payload:v1-variant": {
+        "columns": 2
+      },
+      "get_feature_flag_payload:v2-null": null,
+      "get_feature_flag_payload:v2-number": 12.5,
+      "get_feature_flag_payload:v2-object": {
+        "layout": "compact",
+        "n": [
+          1,
+          true
+        ]
+      },
+      "get_feature_flag_payload:v2-string": null,
+      "get_feature_flag_result:bool-off": [
+        false,
+        null,
+        null,
+        ""
+      ],
+      "get_feature_flag_result:bool-on": [
+        true,
+        null,
+        null,
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:missing": null,
+      "get_feature_flag_result:server-failed": [
+        false,
+        null,
+        null,
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:sparse": [
+        true,
+        "compact",
+        null,
+        null
+      ],
+      "get_feature_flag_result:v1-bool-payload": [
+        true,
+        null,
+        {
+          "cta": "Try it",
+          "n": 1
+        },
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v1-string-payload": [
+        true,
+        null,
+        "plain",
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v1-variant": [
+        true,
+        "control",
+        {
+          "columns": 2
+        },
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v2-null": [
+        false,
+        null,
+        null,
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v2-number": [
+        true,
+        null,
+        12.5,
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v2-object": [
+        true,
+        null,
+        {
+          "layout": "compact",
+          "n": [
+            1,
+            true
+          ]
+        },
+        "Matched condition set 1"
+      ],
+      "get_feature_flag_result:v2-string": [
+        true,
+        "compact",
+        null,
+        "Matched condition set 1"
+      ],
+      "get_feature_flags_and_payloads": {
+        "featureFlagPayloads": {
+          "v1-bool-payload": "{\"cta\": \"Try it\", \"n\": 1}",
+          "v1-string-payload": "\"plain\"",
+          "v1-variant": "{\"columns\": 2}",
+          "v2-number": "12.5",
+          "v2-object": "{\"layout\":\"compact\",\"n\":[1,true]}"
+        },
+        "featureFlags": {
+          "bool-off": false,
+          "bool-on": true,
+          "server-failed": false,
+          "sparse": "compact",
+          "v1-bool-payload": true,
+          "v1-string-payload": true,
+          "v1-variant": "control",
+          "v2-null": false,
+          "v2-number": true,
+          "v2-object": true,
+          "v2-string": "compact"
+        }
+      },
+      "get_feature_payloads": {
+        "v1-bool-payload": "{\"cta\": \"Try it\", \"n\": 1}",
+        "v1-string-payload": "\"plain\"",
+        "v1-variant": "{\"columns\": 2}",
+        "v2-number": "12.5",
+        "v2-object": "{\"layout\":\"compact\",\"n\":[1,true]}"
+      },
+      "get_feature_variants": {
+        "bool-off": false,
+        "bool-on": true,
+        "server-failed": false,
+        "sparse": "compact",
+        "v1-bool-payload": true,
+        "v1-string-payload": true,
+        "v1-variant": "control",
+        "v2-null": false,
+        "v2-number": true,
+        "v2-object": true,
+        "v2-string": "compact"
+      },
+      "get_flags_decision": {
+        "errorsWhileComputingFlags": false,
+        "evaluatedAt": 1800000000000,
+        "flags": {
+          "bool-off": {
+            "__class__": "FeatureFlag",
+            "enabled": false,
+            "key": "bool-off",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": null,
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "no_condition_match",
+              "condition_index": null,
+              "description": ""
+            },
+            "variant": null
+          },
+          "bool-on": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "bool-on",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": null,
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "server-failed": {
+            "__class__": "FeatureFlag",
+            "enabled": false,
+            "key": "server-failed",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": null,
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "sparse": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "sparse",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": "",
+              "has_experiment": null,
+              "id": 0,
+              "payload": null,
+              "version": 0
+            },
+            "reason": null,
+            "variant": "compact"
+          },
+          "v1-bool-payload": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v1-bool-payload",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": "{\"cta\": \"Try it\", \"n\": 1}",
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "v1-string-payload": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v1-string-payload",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": "\"plain\"",
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "v1-variant": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v1-variant",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": "A variant flag",
+              "has_experiment": true,
+              "id": 701,
+              "payload": "{\"columns\": 2}",
+              "version": 4
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": "control"
+          },
+          "v2-null": {
+            "__class__": "FeatureFlag",
+            "enabled": false,
+            "key": "v2-null",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": null,
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "v2-number": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v2-number",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": "12.5",
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "v2-object": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v2-object",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": "{\"layout\":\"compact\",\"n\":[1,true]}",
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": null
+          },
+          "v2-string": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v2-string",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": null,
+              "has_experiment": false,
+              "id": 700,
+              "payload": null,
+              "version": 3
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": "compact"
+          }
+        },
+        "requestId": "60000000-0000-4000-8000-000000000000"
+      },
+      "snapshot.get_flag:bool-off": false,
+      "snapshot.get_flag:bool-on": true,
+      "snapshot.get_flag:missing": null,
+      "snapshot.get_flag:server-failed": false,
+      "snapshot.get_flag:sparse": "compact",
+      "snapshot.get_flag:v1-bool-payload": true,
+      "snapshot.get_flag:v1-string-payload": true,
+      "snapshot.get_flag:v1-variant": "control",
+      "snapshot.get_flag:v2-null": false,
+      "snapshot.get_flag:v2-number": true,
+      "snapshot.get_flag:v2-object": true,
+      "snapshot.get_flag:v2-string": "compact",
+      "snapshot.get_flag_payload:bool-off": null,
+      "snapshot.get_flag_payload:bool-on": null,
+      "snapshot.get_flag_payload:missing": null,
+      "snapshot.get_flag_payload:server-failed": null,
+      "snapshot.get_flag_payload:sparse": null,
+      "snapshot.get_flag_payload:v1-bool-payload": {
+        "cta": "Try it",
+        "n": 1
+      },
+      "snapshot.get_flag_payload:v1-string-payload": "plain",
+      "snapshot.get_flag_payload:v1-variant": {
+        "columns": 2
+      },
+      "snapshot.get_flag_payload:v2-null": null,
+      "snapshot.get_flag_payload:v2-number": 12.5,
+      "snapshot.get_flag_payload:v2-object": {
+        "layout": "compact",
+        "n": [
+          1,
+          true
+        ]
+      },
+      "snapshot.get_flag_payload:v2-string": null,
+      "snapshot.is_enabled:bool-off": false,
+      "snapshot.is_enabled:bool-on": true,
+      "snapshot.is_enabled:missing": false,
+      "snapshot.is_enabled:server-failed": false,
+      "snapshot.is_enabled:sparse": true,
+      "snapshot.is_enabled:v1-bool-payload": true,
+      "snapshot.is_enabled:v1-string-payload": true,
+      "snapshot.is_enabled:v1-variant": true,
+      "snapshot.is_enabled:v2-null": false,
+      "snapshot.is_enabled:v2-number": true,
+      "snapshot.is_enabled:v2-object": true,
+      "snapshot.is_enabled:v2-string": true,
+      "snapshot.keys": [
+        "bool-off",
+        "bool-on",
+        "server-failed",
+        "sparse",
+        "v1-bool-payload",
+        "v1-string-payload",
+        "v1-variant",
+        "v2-null",
+        "v2-number",
+        "v2-object",
+        "v2-string"
+      ]
+    },
+    "getters with an unreadable record": {
+      "events": [
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": null,
+            "$feature_flag": "v1-variant",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": null,
+            "$feature_flag": "v1-variant",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": null,
+            "$feature_flag": "v1-variant",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": null,
+            "$feature_flag": "unreadable",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": null,
+            "$feature_flag": "unreadable",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": null,
+            "$feature_flag": "unreadable",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "unknown_error",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": null,
+            "$feature_flag": "v1-variant",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": null,
+            "$feature_flag": "unreadable",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "snapshot-event",
+          {}
+        ],
+        [
+          "fetched-event",
+          {}
+        ]
+      ],
+      "feature_enabled:missing": null,
+      "feature_enabled:unreadable": null,
+      "feature_enabled:v1-variant": null,
+      "get_all_flags": {},
+      "get_all_flags_and_payloads": {
+        "featureFlagPayloads": {},
+        "featureFlags": {}
+      },
+      "get_feature_flag:missing": null,
+      "get_feature_flag:unreadable": null,
+      "get_feature_flag:v1-variant": null,
+      "get_feature_flag_payload:missing": null,
+      "get_feature_flag_payload:unreadable": null,
+      "get_feature_flag_payload:v1-variant": null,
+      "get_feature_flag_result:missing": null,
+      "get_feature_flag_result:unreadable": null,
+      "get_feature_flag_result:v1-variant": null,
+      "get_feature_flags_and_payloads": {
+        "featureFlagPayloads": {},
+        "featureFlags": {}
+      },
+      "get_feature_payloads": {},
+      "get_feature_variants": {},
+      "get_flags_decision": {
+        "flags": {},
+        "requestId": null
+      },
+      "snapshot.get_flag:missing": null,
+      "snapshot.get_flag:unreadable": null,
+      "snapshot.get_flag:v1-variant": null,
+      "snapshot.get_flag_payload:missing": null,
+      "snapshot.get_flag_payload:unreadable": null,
+      "snapshot.get_flag_payload:v1-variant": null,
+      "snapshot.is_enabled:missing": false,
+      "snapshot.is_enabled:unreadable": false,
+      "snapshot.is_enabled:v1-variant": false,
+      "snapshot.keys": []
+    },
+    "getters with the unreadable record read as disabled": {
+      "events": [
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": false,
+            "$feature_flag": "unreadable",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": false,
+            "$feature_flag": "unreadable",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": false,
+            "$feature_flag": "unreadable",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/v1-variant": "control",
+            "$feature_flag": "v1-variant",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_has_experiment": true,
+            "$feature_flag_id": 701,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
+            "$feature_flag_reason": "Matched condition set 1",
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": "control",
+            "$feature_flag_version": 4,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/unreadable": false,
+            "$feature_flag": "unreadable",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": false,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "$feature_flag_called",
+          {
+            "$feature/missing": null,
+            "$feature_flag": "missing",
+            "$feature_flag_error": "flag_missing",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
+            "$feature_flag_response": null,
+            "locally_evaluated": false
+          }
+        ],
+        [
+          "snapshot-event",
+          {
+            "$active_feature_flags": [
+              "v1-variant"
+            ],
+            "$feature/unreadable": false,
+            "$feature/v1-variant": "control"
+          }
+        ],
+        [
+          "fetched-event",
+          {
+            "$active_feature_flags": [
+              "v1-variant"
+            ],
+            "$feature/unreadable": false,
+            "$feature/v1-variant": "control"
+          }
+        ]
+      ],
+      "feature_enabled:missing": null,
+      "feature_enabled:unreadable": false,
+      "feature_enabled:v1-variant": true,
+      "get_all_flags": {
+        "unreadable": false,
+        "v1-variant": "control"
+      },
+      "get_all_flags_and_payloads": {
+        "featureFlagPayloads": {
+          "v1-variant": "{\"columns\": 2}"
+        },
+        "featureFlags": {
+          "unreadable": false,
+          "v1-variant": "control"
+        }
+      },
+      "get_feature_flag:missing": null,
+      "get_feature_flag:unreadable": false,
+      "get_feature_flag:v1-variant": "control",
+      "get_feature_flag_payload:missing": null,
+      "get_feature_flag_payload:unreadable": null,
+      "get_feature_flag_payload:v1-variant": {
+        "columns": 2
+      },
+      "get_feature_flag_result:missing": null,
+      "get_feature_flag_result:unreadable": [
+        false,
+        null,
+        null,
+        null
+      ],
+      "get_feature_flag_result:v1-variant": [
+        true,
+        "control",
+        {
+          "columns": 2
+        },
+        "Matched condition set 1"
+      ],
+      "get_feature_flags_and_payloads": {
+        "featureFlagPayloads": {
+          "v1-variant": "{\"columns\": 2}"
+        },
+        "featureFlags": {
+          "unreadable": false,
+          "v1-variant": "control"
+        }
+      },
+      "get_feature_payloads": {
+        "v1-variant": "{\"columns\": 2}"
+      },
+      "get_feature_variants": {
+        "unreadable": false,
+        "v1-variant": "control"
+      },
+      "get_flags_decision": {
+        "errorsWhileComputingFlags": false,
+        "evaluatedAt": 1800000000000,
+        "flags": {
+          "unreadable": {
+            "__class__": "FeatureFlag",
+            "enabled": false,
+            "key": "unreadable",
+            "metadata": {
+              "__class__": "LegacyFlagMetadata",
+              "payload": null
+            },
+            "reason": null,
+            "variant": null
+          },
+          "v1-variant": {
+            "__class__": "FeatureFlag",
+            "enabled": true,
+            "key": "v1-variant",
+            "metadata": {
+              "__class__": "FlagMetadata",
+              "description": "A variant flag",
+              "has_experiment": true,
+              "id": 701,
+              "payload": "{\"columns\": 2}",
+              "version": 4
+            },
+            "reason": {
+              "__class__": "FlagReason",
+              "code": "condition_match",
+              "condition_index": 0,
+              "description": "Matched condition set 1"
+            },
+            "variant": "control"
+          }
+        },
+        "requestId": "60000000-0000-4000-8000-000000000000"
+      },
+      "snapshot.get_flag:missing": null,
+      "snapshot.get_flag:unreadable": false,
+      "snapshot.get_flag:v1-variant": "control",
+      "snapshot.get_flag_payload:missing": null,
+      "snapshot.get_flag_payload:unreadable": null,
+      "snapshot.get_flag_payload:v1-variant": {
+        "columns": 2
+      },
+      "snapshot.is_enabled:missing": false,
+      "snapshot.is_enabled:unreadable": false,
+      "snapshot.is_enabled:v1-variant": true,
+      "snapshot.keys": [
+        "unreadable",
+        "v1-variant"
+      ]
+    }
+  }
+}
diff --git a/posthog/test/released_flags_scenarios.py b/posthog/test/released_flags_scenarios.py
new file mode 100644
index 000000000..b3cacdac1
--- /dev/null
+++ b/posthog/test/released_flags_scenarios.py
@@ -0,0 +1,319 @@
+"""Flag scenarios whose results are pinned to a released SDK.
+
+``fixtures/released_flags_7_82_1.json`` holds the results of these scenarios as
+posthog 7.82.1 produced them from the ``v2`` response shape, the shape that release
+requests. ``test_flags_released_behaviour.py`` runs the same scenarios on this SDK
+from the ``v2`` and the ``v4`` shape and compares them with that file.
+
+This module uses only the public client API, so it also runs on 7.82.1. To
+regenerate the file, install ``posthog==7.82.1`` in a separate environment, load this
+module by its path from a directory outside the checkout, so that the installed
+package is imported, and write ``{"description": DESCRIPTION, "results": run_all("v2")}``
+to the file as JSON with sorted keys and an indent of 2.
+"""
+
+import copy
+import dataclasses
+import json
+import warnings
+from typing import Any, Callable, Dict, List, Optional
+from unittest import mock
+
+from requests.exceptions import ConnectionError as RequestsConnectionError
+from requests.exceptions import Timeout as RequestsTimeout
+
+from posthog import Client
+from posthog.request import APIError, QuotaLimitError
+
+DESCRIPTION = (
+    "Results of the scenarios in posthog/test/released_flags_scenarios.py, recorded"
+    " with posthog 7.82.1 from the v2 response shape. See that module to regenerate."
+)
+API_KEY = "phc_released_flags_scenarios"
+DISTINCT_ID = "user-1"
+REQUEST_ID = "60000000-0000-4000-8000-000000000000"
+EVALUATED_AT = 1800000000000
+MATCHED = {
+    "code": "condition_match",
+    "condition_index": 0,
+    "description": "Matched condition set 1",
+}
+
+
+def _flag(key: str, value: Any, **fields: Any) -> Dict[str, Any]:
+    """One flag outcome, rendered into a response by ``build_response``."""
+    flag: Dict[str, Any] = {
+        "key": key,
+        "value": value,
+        "config_version": 1,
+        "payload": None,
+        "metadata": {"id": 700, "version": 3, "description": None},
+        "has_experiment": False,
+        "reason": MATCHED,
+        "failed": False,
+        "set": {},
+    }
+    flag.update(fields)
+    return flag
+
+
+# Flags read by the getter scenario. A config version 2 flag carries a typed value;
+# the v2 response renders it the way the server does for older SDKs.
+GETTER_FLAGS = [
+    _flag("bool-on", True),
+    _flag("bool-off", False, reason={"code": "no_condition_match"}),
+    _flag(
+        "v1-variant",
+        "control",
+        payload='{"columns": 2}',
+        has_experiment=True,
+        metadata={"id": 701, "version": 4, "description": "A variant flag"},
+    ),
+    _flag("v1-bool-payload", True, payload='{"cta": "Try it", "n": 1}'),
+    _flag("v1-string-payload", True, payload='"plain"'),
+    _flag("v2-string", "compact", config_version=2),
+    _flag("v2-null", None, config_version=2),
+    _flag("v2-number", 12.5, config_version=2),
+    _flag("v2-object", {"layout": "compact", "n": [1, True]}, config_version=2),
+    _flag("sparse", "compact", metadata={}, has_experiment=None, reason=None),
+    _flag("server-failed", "compact", failed=True),
+]
+
+
+def build_response(
+    shape: str, flags: List[Dict[str, Any]], **top_level: Any
+) -> Dict[str, Any]:
+    """The ``/flags`` response of the given shape (``"v2"`` or ``"v4"``) for flags."""
+    records: Dict[str, Any] = {}
+    for flag in flags:
+        value = None if flag["failed"] else flag["value"]
+        metadata = None if flag["metadata"] is None else dict(flag["metadata"])
+        if metadata is not None and flag["has_experiment"] is not None:
+            metadata["has_experiment"] = flag["has_experiment"]
+        record: Dict[str, Any] = {"key": flag["key"]}
+        if shape == "v2":
+            typed = flag["config_version"] != 1 and not isinstance(
+                value, (bool, str, type(None))
+            )
+            record["enabled"] = value is not None and value is not False
+            record["variant"] = value if isinstance(value, str) else None
+            if metadata is not None:
+                metadata["payload"] = (
+                    json.dumps(value, separators=(",", ":"))
+                    if typed
+                    else flag["payload"]
+                )
+        else:
+            record["value"] = value
+            if metadata is not None:
+                metadata["config_version"] = flag["config_version"]
+                if flag["config_version"] == 1:
+                    metadata["payload"] = flag["payload"]
+                if isinstance(value, str):
+                    metadata["variant_key"] = value
+        if flag["failed"]:
+            record["failed"] = True
+        if flag["reason"] is not None:
+            record["reason"] = flag["reason"]
+        if metadata is not None:
+            record["metadata"] = metadata
+        record.update(copy.deepcopy(flag["set"]))
+        records[flag["key"]] = record
+    response: Dict[str, Any] = {
+        "flags": records,
+        "errorsWhileComputingFlags": False,
+        "requestId": REQUEST_ID,
+        "evaluatedAt": EVALUATED_AT,
+    }
+    response.update(top_level)
+    return response
+
+
+def plain(value: Any) -> Any:
+    """A JSON-compatible copy of a result, with each dataclass's public fields."""
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        fields = {
+            field.name: plain(getattr(value, field.name))
+            for field in dataclasses.fields(value)
+        }
+        return {"__class__": type(value).__name__, **fields}
+    if isinstance(value, dict):
+        return {str(key): plain(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [plain(item) for item in value]
+    return value
+
+
+def _flag_event_properties(message: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        key: item
+        for key, item in message["properties"].items()
+        if key.startswith("$feature")
+        or key in ("$active_feature_flags", "locally_evaluated")
+    }
+
+
+def _with_client(
+    responses: List[Any], body: Callable[[Client, Dict[str, Any]], None], **options: Any
+) -> Dict[str, Any]:
+    """Run ``body`` on a client whose ``/flags`` requests return ``responses`` in turn."""
+    client = Client(API_KEY, send=False, **options)
+    outputs: Dict[str, Any] = {}
+    events: List[Any] = []
+    pending = list(responses)
+
+    def flags(*args: Any, **kwargs: Any) -> Any:
+        response = pending.pop(0) if len(pending) > 1 else pending[0]
+        if isinstance(response, Exception):
+            raise response
+        return copy.deepcopy(response)
+
+    def enqueue(message: Dict[str, Any], *args: Any, **kwargs: Any) -> Optional[str]:
+        events.append([message["event"], _flag_event_properties(message)])
+        return None
+
+    try:
+        with (
+            mock.patch("posthog.client.flags", side_effect=flags),
+            mock.patch.object(client, "_enqueue", side_effect=enqueue),
+            warnings.catch_warnings(),
+        ):
+            warnings.simplefilter("ignore")
+            body(client, outputs)
+    finally:
+        client.shutdown()
+    outputs["events"] = events
+    return plain(outputs)
+
+
+def _read_every_getter(
+    client: Client, outputs: Dict[str, Any], keys: List[str]
+) -> None:
+    outputs["get_flags_decision"] = client.get_flags_decision(DISTINCT_ID)
+    outputs["get_feature_variants"] = client.get_feature_variants(DISTINCT_ID)
+    outputs["get_feature_payloads"] = client.get_feature_payloads(DISTINCT_ID)
+    outputs["get_feature_flags_and_payloads"] = client.get_feature_flags_and_payloads(
+        DISTINCT_ID
+    )
+    outputs["get_all_flags"] = client.get_all_flags(DISTINCT_ID)
+    outputs["get_all_flags_and_payloads"] = client.get_all_flags_and_payloads(
+        DISTINCT_ID
+    )
+    for key in keys + ["missing"]:
+        result = client.get_feature_flag_result(key, DISTINCT_ID)
+        outputs[f"get_feature_flag_result:{key}"] = (
+            None
+            if result is None
+            else [result.enabled, result.variant, result.payload, result.reason]
+        )
+        outputs[f"get_feature_flag:{key}"] = client.get_feature_flag(key, "user-2")
+        outputs[f"feature_enabled:{key}"] = client.feature_enabled(key, "user-3")
+        outputs[f"get_feature_flag_payload:{key}"] = client.get_feature_flag_payload(
+            key, DISTINCT_ID
+        )
+    snapshot = client.evaluate_flags("snapshot-user")
+    outputs["snapshot.keys"] = sorted(snapshot.keys)
+    for key in keys + ["missing"]:
+        outputs[f"snapshot.is_enabled:{key}"] = snapshot.is_enabled(key)
+        outputs[f"snapshot.get_flag:{key}"] = snapshot.get_flag(key)
+        outputs[f"snapshot.get_flag_payload:{key}"] = snapshot.get_flag_payload(key)
+    client.capture("snapshot-event", distinct_id="snapshot-user", flags=snapshot)
+    client.capture("fetched-event", distinct_id="capture-user", send_feature_flags=True)
+
+
+def getters(shape: str, flags: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Every legacy getter, snapshot read and flag event for one response."""
+    keys = [flag["key"] for flag in flags]
+    return _with_client(
+        [build_response(shape, flags)],
+        lambda client, outputs: _read_every_getter(client, outputs, keys),
+    )
+
+
+def _good(shape: str, **fields: Any) -> Dict[str, Any]:
+    return build_response(
+        shape, [_flag("cached", "blue", payload='{"theme": "dark"}', **fields)]
+    )
+
+
+# Single-flag histories with the memory fallback cache: the responses, in order, to
+# the same flag read for the same user.
+def cache_histories(shape: str) -> Dict[str, List[Any]]:
+    return {
+        "good, unreadable record, timeout": [
+            _good(shape),
+            _good(shape, set={"reason": "oops"}),
+            RequestsTimeout("timed out"),
+        ],
+        "good, each request failure": [
+            _good(shape),
+            RequestsTimeout("timed out"),
+            RequestsConnectionError("refused"),
+            APIError(500, "server error"),
+            QuotaLimitError(429, "quota limited"),
+            ValueError("unexpected"),
+        ],
+        "good, disabled, timeout": [
+            _good(shape),
+            build_response(shape, [_flag("cached", False)]),
+            RequestsTimeout("timed out"),
+        ],
+        "good, server failed, timeout": [
+            _good(shape),
+            _good(shape, failed=True),
+            RequestsTimeout("timed out"),
+        ],
+        "good, missing with errors, timeout": [
+            _good(shape),
+            build_response(shape, [], errorsWhileComputingFlags=True),
+            RequestsTimeout("timed out"),
+        ],
+        "good, other variant, timeout": [
+            _good(shape),
+            build_response(shape, [_flag("cached", "green")]),
+            RequestsTimeout("timed out"),
+        ],
+    }
+
+
+def cache_history(responses: List[Any]) -> Dict[str, Any]:
+    def body(client: Client, outputs: Dict[str, Any]) -> None:
+        results = []
+        for _ in responses:
+            # Forget sent events so that every read sends one, with its error.
+            client.distinct_ids_feature_flags_reported.clear()
+            result = client.get_feature_flag_result("cached", DISTINCT_ID)
+            results.append(
+                None
+                if result is None
+                else [result.enabled, result.variant, result.payload, result.reason]
+            )
+        outputs["results"] = results
+
+    return _with_client(
+        responses + [RequestsTimeout("unused")],
+        body,
+        flag_fallback_cache_url="memory://local/?ttl=300&size=100",
+    )
+
+
+UNREADABLE = _flag("unreadable", "compact", set={"reason": "oops"})
+# What a record that cannot be read reads as: disabled, without reason or metadata.
+UNREADABLE_AS_DISABLED = _flag("unreadable", False, metadata=None, reason=None)
+
+
+def run_all(shape: str) -> Dict[str, Any]:
+    """Every scenario's results for the given response shape."""
+    return {
+        "getters": getters(shape, GETTER_FLAGS),
+        "getters with an unreadable record": getters(
+            shape, [GETTER_FLAGS[2], UNREADABLE]
+        ),
+        "getters with the unreadable record read as disabled": getters(
+            shape, [GETTER_FLAGS[2], UNREADABLE_AS_DISABLED]
+        ),
+        "cache histories": {
+            name: cache_history(responses)
+            for name, responses in cache_histories(shape).items()
+        },
+    }
diff --git a/posthog/test/snapshots/flags_request.json b/posthog/test/snapshots/flags_request.json
index 50a018401..5e08287bd 100644
--- a/posthog/test/snapshots/flags_request.json
+++ b/posthog/test/snapshots/flags_request.json
@@ -28,5 +28,5 @@
     "User-Agent": "posthog-python/<SDK_VERSION>"
   },
   "timeout": 3,
-  "url": "https://example.posthog.test/flags/?v=2"
+  "url": "https://example.posthog.test/flags/?v=4"
 }
diff --git a/posthog/test/test_async_request.py b/posthog/test/test_async_request.py
index 2cc9db24e..6b9e7b59a 100644
--- a/posthog/test/test_async_request.py
+++ b/posthog/test/test_async_request.py
@@ -243,7 +243,7 @@ async def test_async_flags_sends_v2_request_payload():
 
     assert result == {"flags": {}}
     _, args, kwargs = client.calls[0]
-    assert args == ("/flags/?v=2",)
+    assert args == ("/flags/?v=4",)
     payload = json.loads(kwargs["content"])
     assert payload["token"] == "project-key"
     assert "api_key" not in payload
diff --git a/posthog/test/test_feature_flag.py b/posthog/test/test_feature_flag.py
index 9faa56f1c..147a8186f 100644
--- a/posthog/test/test_feature_flag.py
+++ b/posthog/test/test_feature_flag.py
@@ -127,7 +127,7 @@ def test_flag_metadata_from_json(self):
         metadata = FlagMetadata.from_json(resp)
         self.assertEqual(metadata.id, 123)
         self.assertIsNone(metadata.payload)
-        self.assertEqual(metadata.version, 0)  # default value
+        self.assertIsNone(metadata.version)  # absent, not invented
         self.assertEqual(metadata.description, "")  # default value
 
         # Test with None
diff --git a/posthog/test/test_flags_released_behaviour.py b/posthog/test/test_flags_released_behaviour.py
new file mode 100644
index 000000000..7ad8022f8
--- /dev/null
+++ b/posthog/test/test_flags_released_behaviour.py
@@ -0,0 +1,75 @@
+"""Legacy flag results pinned to the results posthog 7.82.1 recorded.
+
+``fixtures/released_flags_7_82_1.json`` was recorded with posthog 7.82.1 from the
+``v2`` response shape; ``released_flags_scenarios.py`` describes the scenarios and how
+to regenerate the file. Each scenario runs here from the ``v2`` shape and from the
+``v4`` shape of the same flags, so a change shared by both readers is caught too.
+Where the expected result differs from 7.82.1, the test says which decision makes
+it differ.
+"""
+
+import copy
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+import pytest
+
+from posthog.test import released_flags_scenarios as scenarios
+
+RELEASED = json.loads(
+    (Path(__file__).with_name("fixtures") / "released_flags_7_82_1.json").read_text(
+        encoding="utf-8"
+    )
+)["results"]
+SHAPES = ["v2", "v4"]
+
+
+@pytest.fixture(scope="module", params=SHAPES)
+def results(request: Any) -> Dict[str, Any]:
+    return scenarios.run_all(request.param)
+
+
+def test_every_legacy_getter_and_event_matches_7_82_1(results):
+    expected = copy.deepcopy(RELEASED["getters"])
+    # A record without a flag ID or version reads them as absent (None), where 7.82.1
+    # read 0. Events already left out both, so only the parsed record differs.
+    sparse = expected["get_flags_decision"]["flags"]["sparse"]["metadata"]
+    assert (sparse["id"], sparse["version"]) == (0, 0)
+    sparse["id"] = sparse["version"] = None
+
+    assert results["getters"] == expected
+
+
+def test_an_unreadable_record_fails_only_itself(results):
+    # 7.82.1 failed the whole response when one record had a field of the wrong
+    # type. That record now fails alone and reads as a disabled flag without reason
+    # or metadata, and its siblings read as before.
+    assert RELEASED["getters with an unreadable record"]["get_all_flags"] == {}
+
+    as_disabled = RELEASED["getters with the unreadable record read as disabled"]
+    assert results["getters with the unreadable record read as disabled"] == as_disabled
+
+    # A single-flag read of the unreadable record still reports what 7.82.1
+    # reported when the whole response failed: an unknown_error and no request
+    # details. Only its value differs, disabled instead of None.
+    expected = copy.deepcopy(as_disabled)
+    released_events = RELEASED["getters with an unreadable record"]["events"]
+    for event, released in zip(expected["events"], released_events):
+        if (
+            released[1].get("$feature_flag") == "unreadable"
+            and released[1].get("$feature_flag_error") == "unknown_error"
+        ):
+            event[1].pop("$feature_flag_request_id")
+            event[1].pop("$feature_flag_evaluated_at")
+            event[1]["$feature_flag_error"] = "unknown_error"
+    assert results["getters with an unreadable record"] == expected
+
+
+@pytest.mark.parametrize("name", sorted(RELEASED["cache histories"]))
+def test_fallback_cache_histories_match_7_82_1(results, name):
+    # An unreadable record now fails only itself, but a single-flag read of it
+    # still reports what 7.82.1 reported when the whole response failed: an
+    # unknown_error, no request details, and the cached value.
+    expected = RELEASED["cache histories"][name]
+    assert results["cache histories"][name] == expected
diff --git a/posthog/test/test_flags_v4_response.py b/posthog/test/test_flags_v4_response.py
new file mode 100644
index 000000000..662011dce
--- /dev/null
+++ b/posthog/test/test_flags_v4_response.py
@@ -0,0 +1,1186 @@
+"""Reading the ``/flags?v=4`` response, checked against the released wire contract.
+
+The files in ``fixtures/feature_flag_rules_v2`` are copied unchanged from a released
+``PostHog/posthog-sdk-test-harness`` contract. ``SOURCE.json`` records the release and
+the digest of each file.
+"""
+
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from unittest import mock
+
+import pytest
+
+from posthog import AsyncPosthog
+from posthog.client import Client
+from posthog.feature_flag_evaluations import FeatureFlagEvaluations
+from posthog.request import RequestsTimeout
+from posthog.test.test_utils import FAKE_TEST_API_KEY
+from posthog.types import (
+    FeatureFlag,
+    FeatureFlagResult,
+    FlagMetadata,
+    FlagReason,
+    normalize_flags_response,
+    to_flags_and_payloads,
+)
+
+FIXTURES = Path(__file__).with_name("fixtures") / "feature_flag_rules_v2"
+DISTINCT_ID = "user-1"
+
+
+def _load(name: str) -> Any:
+    return json.loads((FIXTURES / name).read_text(encoding="utf-8"))
+
+
+READERS = _load("readers.json")
+RESPONSES = _load("responses.json")
+LEGACY_PROJECTION = _load("legacy_projection.json")
+VALUE_CORPUS = _load("v2_value_evaluation.json")
+
+
+def _pointer(pointer: str) -> List[str]:
+    return [
+        token.replace("~1", "/").replace("~0", "~") for token in pointer.split("/")[1:]
+    ]
+
+
+def _build(fixture: Dict[str, Any], case: Dict[str, Any]) -> Dict[str, Any]:
+    """Apply a fixture case: copy its template, remove members, then set members."""
+    document = copy.deepcopy(fixture["templates"][case["template"]])
+    for pointer in case.get("remove", []):
+        *parents, last = _pointer(pointer)
+        target = document
+        for token in parents:
+            target = target[token]
+        del target[last]
+    for pointer, value in case.get("set", {}).items():
+        *parents, last = _pointer(pointer)
+        target = document
+        for token in parents:
+            target = target[token]
+        target[last] = copy.deepcopy(value)
+    return document
+
+
+@pytest.fixture
+def client():
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    yield client
+    client.shutdown()
+
+
+def _evaluate(client: Client, response: Dict[str, Any]) -> FeatureFlagEvaluations:
+    with mock.patch("posthog.client.flags", return_value=copy.deepcopy(response)):
+        return client.evaluate_flags(DISTINCT_ID)
+
+
+def test_vendored_fixtures_match_the_recorded_release_digests():
+    source = _load("SOURCE.json")
+    assert source["release"] == "1.22.0"
+    assert source["contract_version"] == "7.0.0"
+    for name, entry in source["files"].items():
+        digest = hashlib.sha256((FIXTURES / name).read_bytes()).hexdigest()
+        assert digest == entry["sha256"], name
+
+
+# The /flags?v=4 metadata fields that stay private until the typed accessors ship.
+_PRIVATE_METADATA_FIELDS = {
+    "config_version",
+    "rule_type",
+    "rule_id",
+    "variant_key",
+    "forced_variant",
+}
+
+VALID_RESPONSES = [case for case in RESPONSES["cases"] if case["expected"] == "valid"]
+
+
+@pytest.mark.parametrize("case", VALID_RESPONSES, ids=lambda case: case["id"])
+def test_valid_producer_responses_are_retained_as_sent(case):
+    response = _build(RESPONSES, case)
+    records = copy.deepcopy(response["flags"])
+    flags = normalize_flags_response(response)["flags"]
+
+    assert set(flags) == set(records)
+    for key, record in records.items():
+        flag = flags[key]
+        assert flag._value == record["value"]
+        assert flag._failed is record.get("failed", False)
+        assert flag.reason is not None
+        assert flag.reason.code == record["reason"]["code"]
+        assert flag.reason.condition_index == record["reason"]["condition_index"]
+        assert isinstance(flag.metadata, FlagMetadata)
+        for field, value in record["metadata"].items():
+            # Only config version 1 records carry an experiment ID; it is not kept.
+            if field not in ("payload", "experiment_id"):
+                if field in _PRIVATE_METADATA_FIELDS:
+                    field = f"_{field}"
+                assert getattr(flag.metadata, field) == value, field
+
+
+def _typed_response(values: Dict[str, Any]) -> Dict[str, Any]:
+    flags = {}
+    for index, (key, value) in enumerate(values.items()):
+        flags[key] = {
+            "key": key,
+            "value": value,
+            "reason": {
+                "code": "targeting_match",
+                "condition_index": 0,
+                "description": "Matched rule 1",
+            },
+            "metadata": {
+                "id": 300 + index,
+                "version": 2,
+                "config_version": 2,
+                "description": None,
+                "payload": None,
+                "has_experiment": False,
+                "rule_type": "targeted_release",
+                "rule_id": f"30000000-0000-4000-8000-00000000000{index}",
+            },
+        }
+    return {
+        "flags": flags,
+        "errorsWhileComputingFlags": False,
+        "requestId": "30000000-0000-4000-8000-000000000000",
+        "evaluatedAt": 1800000000000,
+    }
+
+
+def _old_server_response(**records: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "flags": {
+            key: {"key": key, "metadata": {"id": 1, "version": 1}, **record}
+            for key, record in records.items()
+        },
+        "errorsWhileComputingFlags": False,
+    }
+
+
+@pytest.mark.parametrize("shape", ["v4", "older"])
+def test_one_log_per_client_for_records_without_typed_values(shape, caplog):
+    if shape == "v4":
+        response = _typed_response({"string-flag": "compact"})
+    else:
+        response = _old_server_response(
+            **{"string-flag": {"enabled": True, "variant": "compact"}}
+        )
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    other_client = Client(FAKE_TEST_API_KEY, send=False)
+    try:
+        with caplog.at_level("INFO", logger="posthog"):
+            for _ in range(2):
+                _evaluate(client, response)
+            _evaluate(other_client, response)
+    finally:
+        client.shutdown()
+        other_client.shutdown()
+
+    logged = [r for r in caplog.records if "no typed flag values" in r.getMessage()]
+    assert len(logged) == (0 if shape == "v4" else 2)
+
+
+async def test_the_async_client_logs_records_without_typed_values_once(caplog):
+    response = _old_server_response(**{"flag": {"enabled": True, "variant": None}})
+    with mock.patch(
+        "posthog.async_client._async_flags",
+        new=mock.AsyncMock(side_effect=lambda *a, **k: copy.deepcopy(response)),
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        with caplog.at_level("INFO", logger="posthog"):
+            await client.evaluate_flags(DISTINCT_ID)
+            snapshot = await client.evaluate_flags(DISTINCT_ID)
+        await client.shutdown()
+
+    assert snapshot.get_flag("flag") is True
+    logged = [r for r in caplog.records if "no typed flag values" in r.getMessage()]
+    assert len(logged) == 1
+
+
+def test_a_failed_record_never_renders_its_value(client):
+    response = _build(RESPONSES, {"template": "error"})
+    response["flags"]["garden-layout"]["value"] = "compact"
+    snapshot = _evaluate(client, response)
+
+    assert snapshot.get_flag("garden-layout") is False
+    assert snapshot.is_enabled("garden-layout", True) is False
+
+
+@pytest.mark.parametrize(
+    "make_record",
+    [
+        lambda **overrides: _record(**{"metadata.config_version": 1, **overrides}),
+        lambda **overrides: _older_record(**overrides),
+    ],
+    ids=["v4", "older"],
+)
+def test_an_unreadable_record_keeps_the_last_good_cached_value(make_record):
+    responses: List[Any] = [
+        {"flags": {"garden-layout": make_record()}, "requestId": "r1"},
+        {"flags": {"garden-layout": make_record(reason="oops")}, "requestId": "r2"},
+        RequestsTimeout("timed out"),
+    ]
+
+    def flags(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        response = responses.pop(0)
+        if isinstance(response, Exception):
+            raise response
+        return response
+
+    client = Client(
+        FAKE_TEST_API_KEY,
+        send=False,
+        flag_fallback_cache_url="memory://local/?ttl=300&size=100",
+    )
+    try:
+        with mock.patch("posthog.client.flags", side_effect=flags):
+            values = [
+                client.get_feature_flag(
+                    "garden-layout", DISTINCT_ID, send_feature_flag_events=False
+                )
+                for _ in range(3)
+            ]
+    finally:
+        client.shutdown()
+
+    # The unreadable record falls back to the cached value instead of replacing it,
+    # so the timeout after it still has the last good value.
+    assert values == ["compact", "compact", "compact"]
+
+
+def test_an_unreadable_record_without_a_cached_value_reads_as_disabled(client):
+    response = {"flags": {"garden-layout": _older_record(reason="oops")}}
+    with mock.patch("posthog.client.flags", return_value=response):
+        assert (
+            client.get_feature_flag(
+                "garden-layout", DISTINCT_ID, send_feature_flag_events=False
+            )
+            is False
+        )
+
+
+def _record(**overrides: Any) -> Dict[str, Any]:
+    record: Dict[str, Any] = {
+        "key": "garden-layout",
+        "value": "compact",
+        "reason": {"code": "targeting_match", "condition_index": 0},
+        "metadata": {
+            "id": 201,
+            "version": 7,
+            "config_version": 2,
+            "has_experiment": False,
+            "payload": None,
+            "rule_type": "targeted_release",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+        },
+    }
+    for path, value in overrides.items():
+        *parents, last = path.split(".")
+        target = record
+        for token in parents:
+            target = target[token]
+        target[last] = value
+    return record
+
+
+@pytest.mark.parametrize(
+    "path, value",
+    [
+        ("value", []),
+        ("value", float("nan")),
+        ("failed", "true"),
+        ("reason", "targeting_match"),
+        ("reason.code", 3),
+        ("reason.condition_index", "0"),
+        ("reason.condition_index", 0.5),
+        ("reason.description", ["Matched"]),
+        ("metadata", []),
+        ("metadata.id", "201"),
+        ("metadata.version", True),
+        ("metadata.config_version", "2"),
+        ("metadata.description", 1),
+        ("metadata.has_experiment", "false"),
+        ("metadata.rule_type", 2),
+        ("metadata.rule_id", 3),
+        ("metadata.experiment_id", "301"),
+        ("metadata.variant_key", True),
+        ("metadata.forced_variant", "yes"),
+    ],
+)
+def test_a_known_field_with_the_wrong_type_fails_only_that_record(path, value):
+    response = {
+        "flags": {
+            "garden-layout": _record(**{path: value}),
+            "sibling": _record(**{"key": "sibling"}),
+        }
+    }
+
+    flags = normalize_flags_response(response)["flags"]
+
+    malformed = flags["garden-layout"]
+    assert malformed._failed is True
+    assert malformed._value is None
+    assert (malformed.enabled, malformed.variant, malformed.get_value()) == (
+        False,
+        None,
+        False,
+    )
+    # The record keeps that it could not be read, apart from a server failure.
+    assert malformed._malformed_field == path
+    sibling = flags["sibling"]
+    assert sibling._failed is False
+    assert sibling._value == "compact"
+    assert sibling._malformed_field is None
+
+
+def test_a_record_that_is_not_an_object_fails_only_that_record():
+    response = {"flags": {"broken": ["compact"], "sibling": _record(key="sibling")}}
+
+    flags = normalize_flags_response(response)["flags"]
+
+    assert flags["broken"]._failed is True
+    assert flags["broken"].get_value() is False
+    assert flags["sibling"]._value == "compact"
+
+
+def test_unknown_fields_and_null_optional_fields_are_ignored():
+    record = _record(**{"future_field": {"nested": True}})
+    record["reason"]["future_reason"] = 1
+    record["metadata"].update(future_metadata=[1], variant_key=None)
+    record["conditions"] = "not read"
+
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+
+    assert flag._failed is False
+    assert flag._value == "compact"
+    assert isinstance(flag.metadata, FlagMetadata)
+    assert flag.metadata._variant_key is None
+
+
+@pytest.mark.parametrize(
+    "field, value",
+    [
+        ("experiment_id", 301),
+        ("holdout_id", 401),
+        ("holdout_id", "401"),
+    ],
+)
+def test_experiment_and_holdout_ids_in_the_metadata_are_ignored(field, value):
+    # Only config version 1 records carry an experiment ID, and no record carries a
+    # holdout ID: experiments link to rules on the server, and holdouts are
+    # rule-local. Neither is kept. An experiment ID of the wrong type is a parse
+    # error, like any known field; a holdout ID is an unknown key.
+    record = _record(**{f"metadata.{field}": value})
+
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+
+    assert flag._failed is False
+    assert flag._value == "compact"
+    assert isinstance(flag.metadata, FlagMetadata)
+    assert not hasattr(flag.metadata, field)
+
+
+def test_a_record_without_value_is_read_as_an_older_server_record():
+    # An older server sends `enabled` and `variant`. Any rule context it carries
+    # is discarded, and the config version reads as 1.
+    record = {
+        "key": "garden-layout",
+        "enabled": True,
+        "variant": "compact",
+        "reason": {"code": "condition_match", "condition_index": 0},
+        "metadata": {
+            "id": 202,
+            "version": 9,
+            "payload": None,
+            "config_version": 2,
+            "rule_type": "experiment",
+            "rule_id": "10000000-0000-4000-8000-000000000001",
+            "variant_key": "compact",
+        },
+    }
+
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+
+    assert flag._value == "compact"
+    assert isinstance(flag.metadata, FlagMetadata)
+    assert flag.metadata._config_version == 1
+    assert flag.metadata._rule_type is None
+    assert flag.metadata._rule_id is None
+    assert flag.metadata._variant_key is None
+
+
+def test_a_failed_older_server_record_is_kept_as_failed():
+    record = {
+        "key": "garden-layout",
+        "enabled": False,
+        "variant": None,
+        "failed": True,
+        "reason": {
+            "code": "timeout",
+            "condition_index": None,
+            "description": "Timed out",
+        },
+        "metadata": {"id": 202, "version": 9, "payload": None},
+    }
+
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+
+    assert flag._failed is True
+    assert flag._value is False
+    assert flag.reason is not None and flag.reason.description == "Timed out"
+
+
+def _older_record(**overrides: Any) -> Dict[str, Any]:
+    record: Dict[str, Any] = {
+        "key": "garden-layout",
+        "enabled": True,
+        "variant": "compact",
+        "failed": False,
+        "reason": {
+            "code": "condition_match",
+            "condition_index": 0,
+            "description": "Matched condition set 1",
+        },
+        "metadata": {
+            "id": 202,
+            "version": 9,
+            "description": "Garden layout",
+            "payload": None,
+            "has_experiment": False,
+        },
+    }
+    for path, value in overrides.items():
+        *parents, last = path.split(".")
+        target = record
+        for token in parents:
+            target = target[token]
+        target[last] = value
+    return record
+
+
+def test_one_unreadable_older_server_record_keeps_its_siblings():
+    response = {
+        "flags": {
+            "bad": {
+                "enabled": True,
+                "variant": None,
+                "reason": "oops",
+                "metadata": {"id": 1, "version": 1, "payload": None},
+            },
+            "good": {
+                "enabled": True,
+                "variant": None,
+                "reason": None,
+                "metadata": {"id": 2, "version": 1, "payload": None},
+            },
+        },
+        "requestId": "x",
+    }
+
+    flags = normalize_flags_response(response)["flags"]
+
+    assert flags["bad"]._failed is True
+    assert flags["bad"]._malformed_field == "reason"
+    assert flags["good"]._failed is False
+    assert flags["good"].get_value() is True
+
+
+def test_a_value_too_deeply_nested_to_encode_fails_only_that_record():
+    deep: Dict[str, Any] = {}
+    inner = deep
+    for _ in range(200_000):
+        inner["a"] = {}
+        inner = inner["a"]
+    response = {
+        "flags": {
+            "deep": _record(key="deep", value=deep),
+            "sibling": _record(key="sibling"),
+        }
+    }
+
+    flags = normalize_flags_response(response)["flags"]
+
+    assert flags["deep"]._failed is True
+    assert flags["deep"]._malformed_field == "value"
+    assert flags["sibling"].get_value() == "compact"
+
+
+@pytest.mark.parametrize(
+    "path, value",
+    [
+        ("key", 123),
+        ("enabled", "true"),
+        ("variant", 3),
+        ("failed", "yes"),
+        ("reason", "condition_match"),
+        ("reason", ""),
+        ("reason.code", 3),
+        ("reason.condition_index", "0"),
+        ("reason.condition_index", 0.5),
+        ("reason.description", ["Matched"]),
+        ("metadata", []),
+        ("metadata.id", "202"),
+        ("metadata.version", True),
+        ("metadata.description", 1),
+        ("metadata.has_experiment", "false"),
+    ],
+)
+def test_a_known_field_with_the_wrong_type_fails_only_that_older_server_record(
+    path, value
+):
+    response = {
+        "flags": {
+            "garden-layout": _older_record(**{path: value}),
+            "sibling": _older_record(key="sibling"),
+        }
+    }
+
+    flags = normalize_flags_response(response)["flags"]
+
+    malformed = flags["garden-layout"]
+    assert malformed.key == "garden-layout"
+    assert malformed._failed is True
+    assert malformed._malformed_field == path
+    assert malformed._value is None
+    assert (malformed.enabled, malformed.variant, malformed.get_value()) == (
+        False,
+        None,
+        False,
+    )
+    sibling = flags["sibling"]
+    assert (
+        sibling
+        == normalize_flags_response(
+            {"flags": {"sibling": _older_record(key="sibling")}}
+        )["flags"]["sibling"]
+    )
+    assert (sibling._failed, sibling._value, sibling._malformed_field) == (
+        False,
+        "compact",
+        None,
+    )
+
+
+def test_a_valid_older_server_record_renders_as_before():
+    flag = normalize_flags_response({"flags": {"garden-layout": _older_record()}})[
+        "flags"
+    ]["garden-layout"]
+
+    assert flag == FeatureFlag(
+        key="garden-layout",
+        enabled=True,
+        variant="compact",
+        reason=FlagReason(
+            code="condition_match",
+            condition_index=0,
+            description="Matched condition set 1",
+        ),
+        metadata=FlagMetadata(
+            id=202,
+            payload=None,
+            version=9,
+            description="Garden layout",
+            has_experiment=False,
+        ),
+    )
+
+
+def test_the_private_v4_details_stay_out_of_the_public_dataclass_fields():
+    # The typed value and rule metadata are private until the typed accessors ship:
+    # repr, equality, hashing and asdict() of a parsed flag see only public fields.
+    record = _record(value={"beds": 4}, **{"metadata.rule_id": "rule-1"})
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+    assert flag._value == {"beds": 4}
+    assert flag.metadata._rule_id == "rule-1"
+
+    public = FeatureFlag(
+        key=flag.key,
+        enabled=flag.enabled,
+        variant=flag.variant,
+        reason=flag.reason,
+        metadata=FlagMetadata(
+            id=flag.metadata.id,
+            payload=flag.metadata.payload,
+            version=flag.metadata.version,
+            description=flag.metadata.description,
+            has_experiment=flag.metadata.has_experiment,
+        ),
+    )
+    assert flag == public
+    assert hash(flag) == hash(public)
+    assert repr(flag) == repr(public)
+    assert asdict(flag) == asdict(public)
+    fields = [*asdict(flag), *asdict(flag)["metadata"]]
+    assert not [name for name in fields if name.startswith("_")]
+
+
+@pytest.mark.parametrize("make_record", [_record, _older_record])
+def test_a_record_key_of_the_wrong_type_fails_only_that_record(make_record):
+    flags = normalize_flags_response(
+        {
+            "flags": {
+                "garden-layout": make_record(key=123),
+                "sibling": make_record(key="sibling"),
+            }
+        }
+    )["flags"]
+
+    assert flags["garden-layout"].key == "garden-layout"
+    assert flags["garden-layout"]._failed is True
+    assert flags["garden-layout"]._malformed_field == "key"
+    assert flags["sibling"]._failed is False
+
+
+@pytest.mark.parametrize("make_record", [_record, _older_record])
+@pytest.mark.parametrize("key", ["other-flag", None])
+def test_a_record_is_read_under_its_map_key(make_record, key):
+    # Reader rules fail a record only for a field of the wrong JSON type. A string
+    # key that differs from the map key is a producer error, so the map key wins.
+    record = make_record(key=key)
+
+    flag = normalize_flags_response({"flags": {"garden-layout": record}})["flags"][
+        "garden-layout"
+    ]
+
+    assert flag.key == "garden-layout"
+    assert flag._failed is False
+    assert flag._value == "compact"
+
+
+def test_a_server_failed_record_is_not_marked_unreadable():
+    flags = normalize_flags_response(
+        {
+            "flags": {
+                "v4": _build(RESPONSES, {"template": "error"})["flags"][
+                    "garden-layout"
+                ],
+                "older": _older_record(failed=True, enabled=False, variant=None),
+            }
+        }
+    )["flags"]
+
+    for flag in flags.values():
+        assert flag._failed is True
+        assert flag._malformed_field is None
+
+
+@pytest.mark.parametrize("make_record", [_record, _older_record])
+def test_absent_flag_id_and_version_stay_absent(make_record, client):
+    record = make_record()
+    record["key"] = "garden-layout"
+    del record["metadata"]["id"]
+    del record["metadata"]["version"]
+    response = {
+        "flags": {"garden-layout": record},
+        "errorsWhileComputingFlags": False,
+        "requestId": "60000000-0000-4000-8000-000000000000",
+    }
+
+    flag = normalize_flags_response(copy.deepcopy(response))["flags"]["garden-layout"]
+    assert isinstance(flag.metadata, FlagMetadata)
+    assert (flag.metadata.id, flag.metadata.version) == (None, None)
+
+    with (
+        mock.patch("posthog.client.flags", return_value=copy.deepcopy(response)),
+        mock.patch.object(client, "capture") as capture,
+    ):
+        client.get_feature_flag_result("garden-layout", DISTINCT_ID)
+    properties = capture.call_args.kwargs["properties"]
+    assert "$feature_flag_id" not in properties
+    assert "$feature_flag_version" not in properties
+
+    # A new client, so the event is not deduplicated against the one above.
+    snapshot_client = Client(FAKE_TEST_API_KEY, send=False)
+    try:
+        with mock.patch.object(snapshot_client, "capture") as capture:
+            _evaluate(snapshot_client, response).get_flag("garden-layout")
+    finally:
+        snapshot_client.shutdown()
+    properties = capture.call_args.kwargs["properties"]
+    assert "$feature_flag_id" not in properties
+    assert "$feature_flag_version" not in properties
+
+
+@pytest.mark.parametrize(
+    "value, encoded", [(25, "25"), ({"columns": 2}, '{"columns":2}')]
+)
+def test_a_number_or_object_value_is_its_own_payload(value, encoded, client):
+    # A config version 2 number or object value is its payload; a payload the
+    # record also sends is ignored.
+    response = _typed_response({"upload-limit": value})
+    response["flags"]["upload-limit"]["metadata"]["payload"] = "999"
+
+    flag = normalize_flags_response(copy.deepcopy(response))["flags"]["upload-limit"]
+    assert flag.metadata.payload == encoded
+
+    snapshot = _evaluate(client, response)
+    assert snapshot.get_flag_payload("upload-limit") == value
+
+
+def test_a_config_version_1_payload_is_kept():
+    response = _typed_response({"bool-flag": True, "string-flag": "compact"})
+    for record in response["flags"].values():
+        record["metadata"].update(config_version=1, payload='{"columns": 2}')
+
+    flags = normalize_flags_response(response)["flags"]
+
+    assert flags["bool-flag"].metadata.payload == '{"columns": 2}'
+    assert flags["string-flag"].metadata.payload == '{"columns": 2}'
+
+
+def test_feature_flag_value_defaults_to_the_legacy_value():
+    assert FeatureFlag.from_value_and_payload("a", "control", None)._value == "control"
+    assert FeatureFlag.from_value_and_payload("a", True, None)._value is True
+    assert FeatureFlag.from_value_and_payload("a", False, None)._value is False
+
+
+class _CustomFlag(FeatureFlag):
+    pass
+
+
+class _CustomMetadata(FlagMetadata):
+    pass
+
+
+class _CustomReason(FlagReason):
+    pass
+
+
+@pytest.mark.parametrize(
+    "record",
+    [
+        _record(),
+        _older_record(),
+        {"key": "garden-layout", "enabled": True},
+        _record(**{"metadata.id": "201"}),
+        _older_record(reason="oops"),
+    ],
+    ids=["v4", "older", "minimal-older", "unreadable-v4", "unreadable-older"],
+)
+def test_from_json_builds_the_subclass_it_is_called_on(record):
+    flag = _CustomFlag.from_json(record)
+
+    assert type(flag) is _CustomFlag
+    assert flag.key == "garden-layout"
+
+
+def test_metadata_and_reason_from_json_build_the_subclass_they_are_called_on():
+    assert type(_CustomMetadata.from_json({"id": 1, "version": 2})) is _CustomMetadata
+    assert type(_CustomReason.from_json({"code": "condition_match"})) is _CustomReason
+
+
+# Legacy accessor parity: a v4 record and the equivalent older-server record must give
+# identical legacy results.
+
+
+def _legacy_maps(response: Dict[str, Any]) -> Dict[str, Any]:
+    maps = to_flags_and_payloads(normalize_flags_response(copy.deepcopy(response)))
+    payloads = maps["featureFlagPayloads"] or {}
+    return {
+        "featureFlags": maps["featureFlags"],
+        "featureFlagPayloads": {
+            key: json.loads(value) for key, value in payloads.items()
+        },
+    }
+
+
+def _v4_record_for_v1_outcome(outcome: Dict[str, Any]) -> Dict[str, Any]:
+    """The v4 record of a v1 flag: ``value`` is the variant, or ``enabled`` without one."""
+    if outcome["failed"]:
+        value = None
+    elif outcome["variant"] is not None:
+        value = outcome["variant"]
+    else:
+        value = outcome["enabled"]
+    metadata: Dict[str, Any] = {
+        "id": outcome["flag_id"],
+        "version": outcome["flag_version"],
+        "config_version": 1,
+        "payload": outcome["payload"],
+        "has_experiment": False,
+    }
+    if outcome["variant"] is not None:
+        metadata["variant_key"] = outcome["variant"]
+    record = {
+        "key": outcome["key"],
+        "value": value,
+        "reason": outcome["reason"],
+        "metadata": metadata,
+    }
+    if outcome["failed"]:
+        record["failed"] = True
+    return record
+
+
+@pytest.mark.parametrize(
+    "case", LEGACY_PROJECTION["cases"], ids=lambda case: case["id"]
+)
+def test_v1_flags_render_the_same_legacy_values_from_both_shapes(case):
+    v2_response = case["projections"]["flags_v2"]
+    v1_maps = case["projections"]["flags_v1"]
+    outcome = case["outcome"]
+    v4_flags = (
+        {}
+        if outcome["omitted"]
+        else {outcome["key"]: _v4_record_for_v1_outcome(outcome)}
+    )
+    v4_response = {
+        "errorsWhileComputingFlags": v2_response["errorsWhileComputingFlags"],
+        "flags": v4_flags,
+    }
+    expected = {
+        "featureFlags": v1_maps["featureFlags"],
+        "featureFlagPayloads": {
+            key: json.loads(value)
+            for key, value in v1_maps["featureFlagPayloads"].items()
+        },
+    }
+
+    assert _legacy_maps(v2_response) == expected
+    assert _legacy_maps(v4_response) == expected
+
+
+VALUE_SUCCESS_CASES = [
+    case for case in VALUE_CORPUS["cases"] if case["expected"]["status"] == "success"
+]
+
+
+def _value_case_records(case: Dict[str, Any]) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    expected, legacy = case["expected"], case["legacy"]
+    rule = expected.get("rule")
+    reason = {
+        "code": expected["reason"],
+        "condition_index": rule["index"] if rule else None,
+        "description": "Evaluated",
+    }
+    metadata = {"id": 401, "version": 3, "description": None, "has_experiment": False}
+    v4_metadata = {**metadata, "config_version": 2, "payload": None}
+    if rule:
+        v4_metadata.update(rule_type=rule["rule_type"], rule_id=rule["id"])
+    payload = legacy["payload"]
+    v2_record = {
+        "key": "typed-flag",
+        "enabled": legacy["enabled"],
+        "variant": legacy["variant"],
+        "reason": reason,
+        "metadata": {
+            **metadata,
+            "payload": None if payload is None else json.dumps(payload),
+        },
+    }
+    v4_record = {
+        "key": "typed-flag",
+        "value": expected["value"],
+        "reason": reason,
+        "metadata": v4_metadata,
+    }
+    return v2_record, v4_record
+
+
+@pytest.mark.parametrize("case", VALUE_SUCCESS_CASES, ids=lambda case: case["id"])
+def test_typed_values_render_the_corpus_legacy_cells_from_both_shapes(case):
+    v2_record, v4_record = _value_case_records(case)
+    legacy = case["legacy"]
+    expected = {
+        "featureFlags": {"typed-flag": legacy["value"]},
+        "featureFlagPayloads": {}
+        if legacy["payload"] is None
+        else {"typed-flag": legacy["payload"]},
+    }
+
+    for record in (v2_record, v4_record):
+        maps = _legacy_maps({"flags": {"typed-flag": record}})
+        assert maps == expected
+        assert type(maps["featureFlags"]["typed-flag"]) is type(legacy["value"])
+        flag = normalize_flags_response(
+            {"flags": {"typed-flag": copy.deepcopy(record)}}
+        )["flags"]["typed-flag"]
+        assert (flag.enabled, flag.variant) == (legacy["enabled"], legacy["variant"])
+        result = FeatureFlagResult.from_flag_details(flag)
+        assert result is not None
+        assert result.get_value() == legacy["value"]
+        assert result.payload == legacy["payload"]
+
+
+def test_a_snapshot_reads_its_flags_from_the_parsed_records(client):
+    response = _typed_response({"object-flag": {"layout": "compact"}, "off": False})
+    response["flags"]["off"]["metadata"]["payload"] = "not json"
+    snapshot = _evaluate(client, response)
+
+    record = snapshot._flags["object-flag"]
+    assert (record.key, record.enabled, record.variant) == ("object-flag", True, None)
+    assert (record.id, record.version, record.reason) == (300, 2, "Matched rule 1")
+    assert record.has_experiment is False
+    assert record.locally_evaluated is False
+    # The payload is decoded once and the same object is returned on every read.
+    payload = snapshot.get_flag_payload("object-flag")
+    assert payload == {"layout": "compact"}
+    assert snapshot.get_flag_payload("object-flag") is payload
+    assert snapshot.get_flag_payload("off") is None
+
+
+def test_number_and_object_payloads_are_compact_json_in_wire_order():
+    response = _typed_response(
+        {"number": 12.5, "object": {"b": "ü", "a": [1, True, None]}}
+    )
+
+    payloads = to_flags_and_payloads(normalize_flags_response(response))[
+        "featureFlagPayloads"
+    ]
+
+    assert payloads == {"number": "12.5", "object": '{"b":"ü","a":[1,true,null]}'}
+
+
+# Every legacy getter and event, end to end: a v2-shaped and a v4-shaped response for
+# the same flags give identical results.
+
+PARITY_FLAGS = [
+    # key, v2 record fields, v4 value
+    ("bool-on", {"enabled": True, "variant": None}, True),
+    ("bool-off", {"enabled": False, "variant": None}, False),
+    ("v1-variant", {"enabled": True, "variant": "control"}, "control"),
+    ("v2-string", {"enabled": True, "variant": "compact"}, "compact"),
+    ("v2-null", {"enabled": False, "variant": None}, None),
+    ("v2-number", {"enabled": True, "variant": None}, 12.5),
+    ("v2-object", {"enabled": True, "variant": None}, {"layout": "compact"}),
+]
+PAYLOADS = {"v1-variant": '{"columns": 2}', "v2-number": "12.5"}
+PAYLOADS["v2-object"] = '{"layout":"compact"}'
+
+
+def _parity_response(shape: str) -> Dict[str, Any]:
+    flags = {}
+    for index, (key, fields, value) in enumerate(PARITY_FLAGS):
+        metadata: Dict[str, Any] = {
+            "id": 500 + index,
+            "version": 4,
+            "description": None,
+            "has_experiment": key == "v1-variant",
+        }
+        reason = {
+            "code": "condition_match",
+            "condition_index": 0,
+            "description": "Matched condition set 1",
+        }
+        if shape == "v2":
+            payload = PAYLOADS.get(key)
+            flags[key] = {
+                "key": key,
+                **fields,
+                "reason": reason,
+                "metadata": {**metadata, "payload": payload},
+            }
+        else:
+            config_version = 1 if key.startswith(("bool", "v1")) else 2
+            payload = PAYLOADS.get(key) if config_version == 1 else None
+            flags[key] = {
+                "key": key,
+                "value": value,
+                "reason": reason,
+                "metadata": {
+                    **metadata,
+                    "config_version": config_version,
+                    "payload": payload,
+                },
+            }
+    return {
+        "flags": flags,
+        "errorsWhileComputingFlags": False,
+        "requestId": "50000000-0000-4000-8000-000000000000",
+        "evaluatedAt": 1800000000000,
+    }
+
+
+def _flag_event_properties(message: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        key: value
+        for key, value in message["properties"].items()
+        if key.startswith("$feature")
+        or key in ("$active_feature_flags", "locally_evaluated")
+    }
+
+
+def _legacy_outputs(shape: str) -> Dict[str, Any]:
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    outputs: Dict[str, Any] = {}
+    events: List[Any] = []
+    keys = [key for key, _, _ in PARITY_FLAGS]
+
+    def response(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return _parity_response(shape)
+
+    def enqueue(message: Dict[str, Any], *args: Any, **kwargs: Any) -> Optional[str]:
+        events.append((message["event"], _flag_event_properties(message)))
+        return None
+
+    try:
+        with (
+            mock.patch("posthog.client.flags", side_effect=response),
+            mock.patch.object(client, "_enqueue", side_effect=enqueue),
+            pytest.warns(DeprecationWarning),
+        ):
+            outputs["get_feature_variants"] = client.get_feature_variants(DISTINCT_ID)
+            outputs["get_feature_payloads"] = client.get_feature_payloads(DISTINCT_ID)
+            outputs["get_feature_flags_and_payloads"] = (
+                client.get_feature_flags_and_payloads(DISTINCT_ID)
+            )
+            outputs["get_all_flags"] = client.get_all_flags(DISTINCT_ID)
+            outputs["get_all_flags_and_payloads"] = client.get_all_flags_and_payloads(
+                DISTINCT_ID
+            )
+            for key in keys + ["missing"]:
+                result = client.get_feature_flag_result(key, DISTINCT_ID)
+                outputs[f"get_feature_flag_result:{key}"] = (
+                    None
+                    if result is None
+                    else (result.enabled, result.variant, result.payload, result.reason)
+                )
+                outputs[f"get_feature_flag:{key}"] = client.get_feature_flag(
+                    key, "other-user"
+                )
+                outputs[f"feature_enabled:{key}"] = client.feature_enabled(
+                    key, "third-user"
+                )
+                outputs[f"get_feature_flag_payload:{key}"] = (
+                    client.get_feature_flag_payload(key, DISTINCT_ID)
+                )
+            snapshot = client.evaluate_flags("snapshot-user")
+            for key in keys + ["missing"]:
+                outputs[f"snapshot.is_enabled:{key}"] = snapshot.is_enabled(key)
+                outputs[f"snapshot.get_flag:{key}"] = snapshot.get_flag(key)
+                outputs[f"snapshot.get_flag_payload:{key}"] = snapshot.get_flag_payload(
+                    key
+                )
+            client.capture(
+                "snapshot-event", distinct_id="snapshot-user", flags=snapshot
+            )
+            client.capture(
+                "fetched-event", distinct_id="capture-user", send_feature_flags=True
+            )
+    finally:
+        client.shutdown()
+    outputs["events"] = events
+    return outputs
+
+
+def test_every_legacy_getter_and_event_is_identical_for_both_shapes():
+    v2_outputs = _legacy_outputs("v2")
+    v4_outputs = _legacy_outputs("v4")
+
+    assert v4_outputs == v2_outputs
+    # Spot-check the legacy rendering itself.
+    assert v4_outputs["get_all_flags"] == {
+        "bool-on": True,
+        "bool-off": False,
+        "v1-variant": "control",
+        "v2-string": "compact",
+        "v2-null": False,
+        "v2-number": True,
+        "v2-object": True,
+    }
+    assert v4_outputs["get_feature_flag_payload:v2-object"] == {"layout": "compact"}
+    assert v4_outputs["snapshot.get_flag_payload:v2-number"] == 12.5
+
+
+def test_feature_flag_called_properties_are_unchanged_for_a_v1_flag(client):
+    response = _build(READERS, {"template": "v1"})
+    with (
+        mock.patch("posthog.client.flags", return_value=response),
+        mock.patch.object(client, "capture") as capture,
+    ):
+        result = client.get_feature_flag_result("garden-layout", DISTINCT_ID)
+
+    assert result is not None
+    assert (result.enabled, result.variant, result.payload) == (
+        True,
+        "compact",
+        {"columns": 2},
+    )
+    capture.assert_called_once_with(
+        "$feature_flag_called",
+        distinct_id=DISTINCT_ID,
+        properties={
+            "$feature_flag": "garden-layout",
+            "$feature_flag_response": "compact",
+            "locally_evaluated": False,
+            "$feature/garden-layout": "compact",
+            "$feature_flag_payload": {"columns": 2},
+            "$feature_flag_request_id": "20000000-0000-4000-8000-000000000002",
+            "$feature_flag_evaluated_at": 1800000000000,
+            "$feature_flag_version": 9,
+            "$feature_flag_id": 202,
+            "$feature_flag_has_experiment": False,
+        },
+        groups={},
+        disable_geoip=None,
+    )
+
+
+async def test_async_client_keeps_healthy_flags_beside_unreadable_and_sparse_ones():
+    sparse = _record(key="sparse")
+    del sparse["metadata"]["id"], sparse["metadata"]["version"]
+    response = {
+        "flags": {
+            "bad-older": _older_record(key="bad-older", reason="oops"),
+            "bad-v4": _record(key="bad-v4", **{"metadata.id": "202"}),
+            "sparse": sparse,
+            "healthy": _older_record(key="healthy"),
+        },
+        "requestId": "x",
+    }
+    with mock.patch(
+        "posthog.async_client._async_flags", new=mock.AsyncMock(return_value=response)
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        with mock.patch.object(client, "capture") as capture:
+            snapshot = await client.evaluate_flags(DISTINCT_ID)
+            assert snapshot.get_flag("bad-older") is False
+            assert snapshot.get_flag("bad-v4") is False
+            assert snapshot.get_flag("sparse") == "compact"
+            assert snapshot.get_flag("healthy") == "compact"
+        await client.shutdown()
+
+    sparse_event = next(
+        call.kwargs["properties"]
+        for call in capture.call_args_list
+        if call.kwargs["properties"]["$feature_flag"] == "sparse"
+    )
+    assert "$feature_flag_id" not in sparse_event
+    assert "$feature_flag_version" not in sparse_event
+
+
+async def test_async_client_reads_the_v4_response():
+    with mock.patch(
+        "posthog.async_client._async_flags",
+        new=mock.AsyncMock(
+            return_value=_typed_response(
+                {"float-flag": 12.5, "object-flag": {"layout": "compact"}}
+            )
+        ),
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        await client.shutdown()
+
+    assert snapshot.get_flag("object-flag") is True
+    assert snapshot.get_flag_payload("object-flag") == {"layout": "compact"}
+    assert snapshot.get_flag("float-flag") is True
+    assert snapshot.get_flag_payload("float-flag") == 12.5
diff --git a/posthog/types.py b/posthog/types.py
index 994b0786c..85938a939 100644
--- a/posthog/types.py
+++ b/posthog/types.py
@@ -1,8 +1,21 @@
 import json
 import logging
+import math
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Callable, List, Optional, TypedDict, Union, cast
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Type,
+    TypedDict,
+    TypeVar,
+    Union,
+    cast,
+)
 
 FlagValue = Union[bool, str]
 
@@ -162,40 +175,75 @@ class FlagMetadata:
     """Feature flag metadata returned by the feature flag API.
 
     Attributes:
-        id: Numeric feature flag ID.
-        payload: Payload configured for the matched flag value, if any.
-        version: Feature flag version.
+        id: Numeric feature flag ID, or ``None`` when the record has none.
+        payload: Payload configured for the matched flag value, if any. For a
+            number or object value it is the value encoded as JSON, the way
+            servers before ``/flags?v=4`` sent it.
+        version: Feature flag version, or ``None`` when the record has none.
         description: Feature flag description.
         has_experiment: Whether the flag has a linked experiment. ``None`` when
             the server does not report the field (older deployments).
     """
 
-    id: int
+    id: Optional[int]
     payload: Optional[str]
-    version: int
+    version: Optional[int]
     description: str
     has_experiment: Optional[bool] = None
+    # Work in progress: the ``/flags?v=4`` metadata is private until the typed flag
+    # value accessors ship. It is kept in instance attributes, not dataclass fields,
+    # so ``repr``, equality, hashing and ``dataclasses.asdict`` see only the public
+    # fields; these class attributes are the defaults. ``_config_version`` is the
+    # configuration format of the flag (``1`` for a record without a typed
+    # ``value``); the rule fields name the rule that produced the result, and the
+    # variant fields the assigned variant.
+    _config_version: ClassVar[Optional[int]] = None
+    _rule_type: ClassVar[Optional[str]] = None
+    _rule_id: ClassVar[Optional[str]] = None
+    _variant_key: ClassVar[Optional[str]] = None
+    _forced_variant: ClassVar[Optional[bool]] = None
 
     @classmethod
     def from_json(cls, resp: Any) -> Union["FlagMetadata", LegacyFlagMetadata]:
+        """Parse the metadata of a record without a typed ``value``.
+
+        Such a record comes from a server before ``/flags?v=4``, so only the
+        fields that response carries are read, and ``config_version`` is ``1``.
+        """
         if not resp:
             return LegacyFlagMetadata(payload=None)
         raw_has_experiment = resp.get("has_experiment")
-        return cls(
-            id=resp.get("id", 0),
+        metadata = cls(
+            id=resp.get("id"),
             payload=resp.get("payload"),
-            version=resp.get("version", 0),
+            version=resp.get("version"),
             description=resp.get("description", ""),
             has_experiment=raw_has_experiment
             if isinstance(raw_has_experiment, bool)
             else None,
         )
+        return _set_private_fields(metadata, _config_version=1)
+
+
+_T = TypeVar("_T")
+
+
+def _set_private_fields(obj: _T, **fields: Any) -> _T:
+    """Set the private, work-in-progress attributes of a frozen dataclass."""
+    for name, value in fields.items():
+        # A value that is already the default is not stored on the instance.
+        if getattr(obj, name) is not value:
+            object.__setattr__(obj, name, value)
+    return obj
 
 
 @dataclass(frozen=True)
 class FeatureFlag:
     """Detailed feature flag evaluation returned by the flags API.
 
+    ``enabled``, ``variant`` and ``metadata.payload`` are the value rendered the way
+    responses before ``/flags?v=4`` carried it, which the legacy getters return.
+
     Attributes:
         key: Feature flag key.
         enabled: Whether the flag is enabled for the evaluated user or group.
@@ -209,29 +257,38 @@ class FeatureFlag:
     variant: Optional[str]
     reason: Optional[FlagReason]
     metadata: Union[FlagMetadata, LegacyFlagMetadata]
+    # Work in progress: private until the typed flag value accessors ship. Like the
+    # private ``FlagMetadata`` attributes, these are instance attributes, not
+    # dataclass fields. ``_value`` is the typed flag value: a boolean, string,
+    # number, object, or ``None`` when the flag has no value; it defaults to
+    # ``variant``, or ``enabled`` when there is no variant. ``_failed`` says whether
+    # the flag failed to evaluate, or its record could not be read.
+    _value: ClassVar[Any] = None
+    _failed: ClassVar[bool] = False
+    # The wire path of the field that made the record unreadable, such as
+    # ``"metadata.id"``. ``None`` unless the record could not be read; a record the
+    # server marks failed has ``_failed`` set and this ``None``.
+    _malformed_field: ClassVar[Optional[str]] = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "_value",
+            self.variant if self.variant is not None else self.enabled,
+        )
 
     def get_value(self) -> FlagValue:
         return self.variant or self.enabled
 
     @classmethod
     def from_json(cls, resp: Any) -> "FeatureFlag":
-        reason = None
-        if resp.get("reason"):
-            reason = FlagReason.from_json(resp.get("reason"))
-
-        metadata = None
-        if resp.get("metadata"):
-            metadata = FlagMetadata.from_json(resp.get("metadata"))
-        else:
-            metadata = LegacyFlagMetadata(payload=None)
+        """Parse one flag record of a ``/flags`` response.
 
-        return cls(
-            key=resp.get("key"),
-            enabled=resp.get("enabled"),
-            variant=resp.get("variant"),
-            reason=reason,
-            metadata=metadata,
-        )
+        A record with a ``value`` member is a ``/flags?v=4`` record. A record
+        without one comes from an older server: its value is ``variant``, or
+        ``enabled`` when there is no variant, and its config version is ``1``.
+        """
+        return _parse_record(cls, resp.get("key"), resp)
 
     @classmethod
     def from_value_and_payload(
@@ -249,6 +306,230 @@ def from_value_and_payload(
         )
 
 
+_F = TypeVar("_F", bound=FeatureFlag)
+
+
+class _MalformedRecord(Exception):
+    """A known field of a flag record has the wrong JSON type."""
+
+
+def _read_int(value: Any, field: str) -> Optional[int]:
+    # JSON has one number type, so an integral number such as 2.0 is an integer.
+    if value is None:
+        return None
+    if isinstance(value, int) and not isinstance(value, bool):
+        return value
+    if isinstance(value, float) and math.isfinite(value) and value.is_integer():
+        return int(value)
+    raise _MalformedRecord(field)
+
+
+def _read_typed(value: Any, field: str, expected: type) -> Any:
+    if value is None or isinstance(value, expected):
+        return value
+    raise _MalformedRecord(field)
+
+
+def _read_value(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, str, dict)):
+        return value
+    if isinstance(value, int) or (isinstance(value, float) and math.isfinite(value)):
+        return value
+    raise _MalformedRecord("value")
+
+
+def _legacy_rendering(value: Any) -> tuple[bool, Optional[str], Optional[str]]:
+    """Render a typed value as ``(enabled, variant, encoded payload)``.
+
+    A string is the variant, ``None`` is disabled, and a number or object is enabled
+    with the value as a JSON-encoded payload, as servers before ``/flags?v=4`` sent it.
+    """
+    if value is None or isinstance(value, bool):
+        return bool(value), None, None
+    if isinstance(value, str):
+        return True, value, None
+    return True, None, json.dumps(value, separators=(",", ":"), ensure_ascii=False)
+
+
+def _parse_typed_record(cls: Type[_F], key: str, resp: Any) -> _F:
+    """Parse a ``/flags?v=4`` record, which carries a typed ``value``.
+
+    Unknown fields are ignored. A known field with the wrong JSON type fails only
+    this record, which then reads as disabled. An absent or null field reads as absent,
+    except ``value``, where null means the flag has no value.
+    """
+    try:
+        if not isinstance(resp, dict):
+            raise _MalformedRecord("record")
+        _read_record_key(resp)
+        value = _read_value(resp.get("value"))
+        failed = _read_typed(resp.get("failed"), "failed", bool) is True
+
+        reason = None
+        raw_reason = _read_typed(resp.get("reason"), "reason", dict)
+        if raw_reason is not None:
+            reason = FlagReason(
+                code=_read_typed(raw_reason.get("code"), "reason.code", str) or "",
+                condition_index=_read_int(
+                    raw_reason.get("condition_index"), "reason.condition_index"
+                ),
+                description=_read_typed(
+                    raw_reason.get("description"), "reason.description", str
+                )
+                or "",
+            )
+
+        if failed:
+            # A failed record has no value, whatever it carries.
+            value = None
+        enabled, variant, encoded_payload = _legacy_rendering(value)
+
+        metadata: Union[FlagMetadata, LegacyFlagMetadata]
+        raw_metadata = _read_typed(resp.get("metadata"), "metadata", dict)
+        if raw_metadata is None:
+            metadata = LegacyFlagMetadata(payload=encoded_payload)
+        else:
+            metadata = FlagMetadata(
+                id=_read_int(raw_metadata.get("id"), "metadata.id"),
+                # A number or object value is its own payload; a payload the record
+                # also carries is ignored.
+                payload=encoded_payload
+                if encoded_payload is not None
+                else raw_metadata.get("payload"),
+                version=_read_int(raw_metadata.get("version"), "metadata.version"),
+                description=_read_typed(
+                    raw_metadata.get("description", ""), "metadata.description", str
+                ),
+                has_experiment=_read_typed(
+                    raw_metadata.get("has_experiment"), "metadata.has_experiment", bool
+                ),
+            )
+            _set_private_fields(
+                metadata,
+                _config_version=_read_int(
+                    raw_metadata.get("config_version"), "metadata.config_version"
+                ),
+                _rule_type=_read_typed(
+                    raw_metadata.get("rule_type"), "metadata.rule_type", str
+                ),
+                _rule_id=_read_typed(
+                    raw_metadata.get("rule_id"), "metadata.rule_id", str
+                ),
+                _variant_key=_read_typed(
+                    raw_metadata.get("variant_key"), "metadata.variant_key", str
+                ),
+                _forced_variant=_read_typed(
+                    raw_metadata.get("forced_variant"), "metadata.forced_variant", bool
+                ),
+            )
+            # Only config version 1 records carry an experiment ID. It is checked,
+            # like every known field, but not kept.
+            _read_int(raw_metadata.get("experiment_id"), "metadata.experiment_id")
+    except _MalformedRecord as error:
+        return _malformed_record(cls, key, str(error))
+    except RecursionError:
+        # A value nested too deeply to encode as a payload fails only this record.
+        return _malformed_record(cls, key, "value")
+
+    flag = cls(
+        key=key,
+        enabled=enabled,
+        variant=variant,
+        reason=reason,
+        metadata=metadata,
+    )
+    return _set_private_fields(flag, _value=value, _failed=failed)
+
+
+def _parse_older_record(cls: Type[_F], key: str, resp: Dict[str, Any]) -> _F:
+    """Parse a record without a typed ``value``, from a server before ``/flags?v=4``.
+
+    Its value is ``variant``, or ``enabled`` when there is no variant, and its config
+    version is ``1``. As for a ``/flags?v=4`` record, a known field with the wrong
+    JSON type fails only this record.
+    """
+    try:
+        _read_record_key(resp)
+        _read_typed(resp.get("enabled"), "enabled", bool)
+        _read_typed(resp.get("variant"), "variant", str)
+        _read_typed(resp.get("failed"), "failed", bool)
+        raw_reason = _read_typed(resp.get("reason"), "reason", dict)
+        if raw_reason:
+            _read_typed(raw_reason.get("code"), "reason.code", str)
+            _read_int(raw_reason.get("condition_index"), "reason.condition_index")
+            _read_typed(raw_reason.get("description"), "reason.description", str)
+        raw_metadata = _read_typed(resp.get("metadata"), "metadata", dict)
+        if raw_metadata:
+            _read_int(raw_metadata.get("id"), "metadata.id")
+            _read_int(raw_metadata.get("version"), "metadata.version")
+            _read_typed(raw_metadata.get("description"), "metadata.description", str)
+            _read_typed(
+                raw_metadata.get("has_experiment"), "metadata.has_experiment", bool
+            )
+    except _MalformedRecord as error:
+        return _malformed_record(cls, key, str(error))
+
+    flag = cls(
+        key=key,
+        # An older server always sends ``enabled``; a record without it keeps
+        # ``None``, as before.
+        enabled=cast(bool, resp.get("enabled")),
+        variant=resp.get("variant"),
+        reason=FlagReason.from_json(raw_reason),
+        metadata=FlagMetadata.from_json(raw_metadata),
+    )
+    return _set_private_fields(flag, _failed=resp.get("failed") is True)
+
+
+def _read_record_key(resp: Dict[str, Any]) -> None:
+    # The flag key is the record's map key. A ``key`` member of the wrong type fails
+    # the record, like any known field; a string that differs is ignored.
+    _read_typed(resp.get("key"), "key", str)
+
+
+def _malformed_record(cls: Type[_F], key: str, malformed_field: str) -> _F:
+    """A record with a known field of the wrong JSON type: failed, and disabled."""
+    flag = cls(
+        key=key,
+        enabled=False,
+        variant=None,
+        reason=None,
+        metadata=LegacyFlagMetadata(payload=None),
+    )
+    return _set_private_fields(
+        flag, _value=None, _failed=True, _malformed_field=malformed_field
+    )
+
+
+def _parse_record(cls: Type[_F], key: str, resp: Any) -> _F:
+    """Parse one record of a ``/flags`` response, stored under ``key``."""
+    if isinstance(resp, dict) and "value" not in resp:
+        return _parse_older_record(cls, key, resp)
+    return _parse_typed_record(cls, key, resp)
+
+
+def _has_untyped_flag_records(resp: Any) -> bool:
+    """Whether a raw ``/flags`` response has a record without a typed ``value``.
+
+    Such a record comes from a server that does not send ``/flags?v=4`` records.
+    """
+    if not isinstance(resp, dict):
+        return False
+    flags = resp.get("flags")
+    if isinstance(flags, dict):
+        return any(
+            isinstance(record, dict) and "value" not in record
+            for record in flags.values()
+        )
+    return bool(resp.get("featureFlags"))
+
+
+_UNTYPED_FLAGS_RESPONSE_MESSAGE = (
+    "[FEATURE FLAGS] The /flags response has no typed flag values, so the server"
+    " may not support /flags?v=4. Every flag is read as config version 1."
+)
+
+
 class FlagsResponse(TypedDict, total=False):
     """Normalized response from the PostHog feature flags API."""
 
@@ -366,7 +647,7 @@ def normalize_flags_response(resp: Any) -> FlagsResponse:
     Normalize the response from the flags API endpoint into a FlagsResponse.
 
     Args:
-        resp: A v1 or v2 response from the flags API endpoint.
+        resp: A v1, v2 or v4 response from the flags API endpoint.
 
     Returns:
         A FlagsResponse containing feature flags and their details.
@@ -379,8 +660,7 @@ def normalize_flags_response(resp: Any) -> FlagsResponse:
         for key, value in flags.items():
             if isinstance(value, FeatureFlag):
                 continue
-            value["key"] = key
-            flags[key] = FeatureFlag.from_json(value)
+            flags[key] = _parse_record(FeatureFlag, key, value)
     else:
         # Handle legacy format
         featureFlags = resp.get("featureFlags", {})
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 5f03d188d..9db790cea 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -1182,9 +1182,9 @@ attribute posthog.types.FeatureFlagResult.reason: Optional[str]
 attribute posthog.types.FeatureFlagResult.variant: Optional[str]
 attribute posthog.types.FlagMetadata.description: str
 attribute posthog.types.FlagMetadata.has_experiment: Optional[bool] = None
-attribute posthog.types.FlagMetadata.id: int
+attribute posthog.types.FlagMetadata.id: Optional[int]
 attribute posthog.types.FlagMetadata.payload: Optional[str]
-attribute posthog.types.FlagMetadata.version: int
+attribute posthog.types.FlagMetadata.version: Optional[int]
 attribute posthog.types.FlagReason.code: str
 attribute posthog.types.FlagReason.condition_index: Optional[int]
 attribute posthog.types.FlagReason.description: str
@@ -1378,7 +1378,7 @@ class posthog.types.FeatureFlag(key: str, enabled: bool, variant: Optional[str],
 class posthog.types.FeatureFlagError 
 class posthog.types.FeatureFlagEvaluationRuntime 
 class posthog.types.FeatureFlagResult(key: str, enabled: bool, variant: Optional[str], payload: Optional[Any], reason: Optional[str])
-class posthog.types.FlagMetadata(id: int, payload: Optional[str], version: int, description: str, has_experiment: Optional[bool] = None)
+class posthog.types.FlagMetadata(id: Optional[int], payload: Optional[str], version: Optional[int], description: str, has_experiment: Optional[bool] = None)
 class posthog.types.FlagReason(code: str, condition_index: Optional[int], description: str)
 class posthog.types.FlagsAndPayloads 
 class posthog.types.FlagsResponse 
diff --git a/sdk_compliance_adapter/adapter.py b/sdk_compliance_adapter/adapter.py
index 8ff4ffff7..d205d1792 100644
--- a/sdk_compliance_adapter/adapter.py
+++ b/sdk_compliance_adapter/adapter.py
@@ -311,6 +311,8 @@ def health():
         else ["capture_v0", "capture_ai_v0", "encoding_gzip"]
     )
     capabilities.append("feature_flags_local_evaluation_v1")
+    # Remote /flags requests send ?v=4 and read the v4 flag record.
+    capabilities.append("flags_response_v4")
     return jsonify(
         {
             "sdk_name": "posthog-python",
diff --git a/sdk_compliance_adapter/test_adapter.py b/sdk_compliance_adapter/test_adapter.py
index 8acc78386..0f40f20fc 100644
--- a/sdk_compliance_adapter/test_adapter.py
+++ b/sdk_compliance_adapter/test_adapter.py
@@ -86,6 +86,7 @@ def test_health_opts_into_local_evaluation_without_losing_capture(
     monkeypatch.setattr(adapter, "CAPTURE_MODE", mode)
     capabilities = adapter.app.test_client().get("/health").json["capabilities"]
     assert "feature_flags_local_evaluation_v1" in capabilities
+    assert "flags_response_v4" in capabilities
     assert capability in capabilities
     assert "capture_ai_v0" in capabilities
 

From 43c7545717f0941c700f13679e365433ff4d5995 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 3 Nov 2026 13:02:17 +0000
Subject: [PATCH 169/245] chore: Release v7.83.0 [skip ci]

---
 .sampo/changesets/flags-v4-response.md | 5 -----
 openfeature-provider/CHANGELOG.md      | 6 ++++++
 openfeature-provider/pyproject.toml    | 2 +-
 posthog/CHANGELOG.md                   | 6 ++++++
 posthog/version.py                     | 2 +-
 pyproject.toml                         | 2 +-
 uv.lock                                | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/flags-v4-response.md

diff --git a/.sampo/changesets/flags-v4-response.md b/.sampo/changesets/flags-v4-response.md
deleted file mode 100644
index 829f5b02f..000000000
--- a/.sampo/changesets/flags-v4-response.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Request `/flags?v=4` and read each flag's typed value, reason and metadata. They stay internal for now: this release adds no public methods, fields or types for them, and `repr`, equality and `dataclasses.asdict` of a flag show only its existing fields. Servers that still send the older response keep working, and a flag record with a field of the wrong JSON type fails only that flag. For valid flag records, existing getters, callbacks and `$feature_flag_called` properties return the same values as before: a number or object value reads as `True`, with the value as its payload. Two things can differ: the human-readable reason text of a config version 2 flag is the one the server sends at v4, and a record with a known field of the wrong JSON type (for example a string `reason`) now reads as a failed flag instead of being read anyway or failing the whole response. The SDK logs once per client when a server sends a response without typed values. `FlagMetadata.id` and `FlagMetadata.version` are `None` when a record has none, instead of `0`, so their type is now `Optional[int]`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 855f7952f..1c1793814 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.141 — 2026-11-03
+
+### Patch changes
+
+- Updated dependencies: posthog@7.83.0
+
 ## 0.1.140 — 2026-11-02
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index f6a41813d..59ecaa1d1 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.140"
+version = "0.1.141"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 333c2e0d7..631a7caac 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.83.0 — 2026-11-03
+
+### Minor changes
+
+- [e094dc5](https://github.com/posthog/posthog-python/commit/e094dc59522b8d7d7b68a74cac4259a61daef60f) Request `/flags?v=4` and read each flag's typed value, reason and metadata. They stay internal for now: this release adds no public methods, fields or types for them, and `repr`, equality and `dataclasses.asdict` of a flag show only its existing fields. Servers that still send the older response keep working, and a flag record with a field of the wrong JSON type fails only that flag. For valid flag records, existing getters, callbacks and `$feature_flag_called` properties return the same values as before: a number or object value reads as `True`, with the value as its payload. Two things can differ: the human-readable reason text of a config version 2 flag is the one the server sends at v4, and a record with a known field of the wrong JSON type (for example a string `reason`) now reads as a failed flag instead of being read anyway or failing the whole response. The SDK logs once per client when a server sends a response without typed values. `FlagMetadata.id` and `FlagMetadata.version` are `None` when a record has none, instead of `0`, so their type is now `Optional[int]`. — Thanks @andehen!
+
 ## 7.82.2 — 2026-11-02
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 798aad33f..36d7c0455 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.82.2"
+VERSION = "7.83.0"
diff --git a/pyproject.toml b/pyproject.toml
index da14bebf7..990c0c6a3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.82.2"
+version = "7.83.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 9efc09a70..2c945cc7d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.140"
+version = "0.1.141"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.82.2"
+version = "7.83.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 314fad070507fce6a95ebb58d8a550f18a1a34ac Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 3 Nov 2026 13:02:21 +0000
Subject: [PATCH 170/245] Update generated references

---
 .../posthog-python-references-7.83.0.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    6 +-
 2 files changed, 3569 insertions(+), 3 deletions(-)
 create mode 100644 references/posthog-python-references-7.83.0.json

diff --git a/references/posthog-python-references-7.83.0.json b/references/posthog-python-references-7.83.0.json
new file mode 100644
index 000000000..ea89d2637
--- /dev/null
+++ b/references/posthog-python-references-7.83.0.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.83.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 39752929b..ea89d2637 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.82.2",
+    "version": "7.83.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -83,7 +83,7 @@
       "properties": [
         {
           "name": "id",
-          "type": "int",
+          "type": "Optional[int]",
           "description": "Field: id"
         },
         {
@@ -93,7 +93,7 @@
         },
         {
           "name": "version",
-          "type": "int",
+          "type": "Optional[int]",
           "description": "Field: version"
         },
         {

From 0c12ca1521f6538873e00f5240cad306c9bba455 Mon Sep 17 00:00:00 2001
From: Connor Grady <50903811+connor-grady@users.noreply.github.com>
Date: Tue, 3 Nov 2026 07:57:45 -0600
Subject: [PATCH 171/245] fix(mcp): inject context into mcp 2.x tool objects
 and test without fastmcp (#1166)

* test(mcp): share the dual-major structured content reader

* test(mcp): read structured content without the fastmcp camelcase shim

* fix(mcp): inject context into mcp 2.x tool objects

* ci: run the mcp 2.x suite without fastmcp
---
 .github/workflows/ci.yml                     | 16 +++++++++---
 .sampo/changesets/bold-lord-hiisi.md         |  5 ++++
 posthog/mcp/posthog_mcp.py                   |  4 +--
 posthog/test/mcp/_helpers.py                 | 11 +++++++++
 posthog/test/mcp/conftest.py                 |  5 ++--
 posthog/test/mcp/test_output_instructions.py | 18 ++++++--------
 posthog/test/mcp/test_posthog_mcp.py         | 26 +++++++++++++++++++-
 7 files changed, 66 insertions(+), 19 deletions(-)
 create mode 100644 .sampo/changesets/bold-lord-hiisi.md

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0a605fc14..ecbc6914c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -156,14 +156,22 @@ jobs:
         # the lockfile's mcp 1.x (also exercised incidentally by the `tests`
         # matrix — this leg exists as an explicit, named signal); the v2 leg
         # (spec 2026-07-28) swaps in mcp>=2 and standalone FastMCP 4, which uses
-        # the v2 registry. posthog/test/mcp/conftest.py splits collection by major.
+        # the v2 registry. The v2-bare leg runs mcp>=2 without FastMCP: importing
+        # FastMCP 4 patches camelCase properties onto mcp_types models for the
+        # whole process, which hides reads that plain mcp 2.x rejects.
+        # posthog/test/mcp/conftest.py splits collection by major.
         name: MCP SDK ${{ matrix.mcp-major }} (Python ${{ matrix.python-version }})
         runs-on: ubuntu-latest
         timeout-minutes: 20
         strategy:
             matrix:
                 python-version: ['3.10', '3.14']
-                mcp-major: ['v1', 'v2']
+                mcp-major: ['v1', 'v2', 'v2-bare']
+                include:
+                    - mcp-major: 'v2'
+                      mcp-packages: "'mcp>=2,<3' 'fastmcp>=4,<5'"
+                    - mcp-major: 'v2-bare'
+                      mcp-packages: "'mcp>=2,<3'"
 
         steps:
             - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -187,11 +195,11 @@ jobs:
                   UV_PROJECT_ENVIRONMENT=$pythonLocation uv sync --extra test
 
             - name: Swap in MCP SDK v2
-              if: matrix.mcp-major == 'v2'
+              if: matrix.mcp-major != 'v1'
               shell: bash
               run: |
                   uv pip uninstall --python "$pythonLocation" fastmcp
-                  uv pip install --python "$pythonLocation" 'mcp>=2,<3' 'fastmcp>=4,<5'
+                  uv pip install --python "$pythonLocation" ${{ matrix.mcp-packages }}
 
             - name: Run MCP tests against SDK ${{ matrix.mcp-major }}
               run: |
diff --git a/.sampo/changesets/bold-lord-hiisi.md b/.sampo/changesets/bold-lord-hiisi.md
new file mode 100644
index 000000000..422365623
--- /dev/null
+++ b/.sampo/changesets/bold-lord-hiisi.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+`PostHogMCP.prepare_tool_list` now adds the `context` argument to MCP SDK 2.x `Tool` objects. It only added it to dicts and 1.x `Tool` objects before, so `$mcp_intent` was never captured for 2.x tool objects.
diff --git a/posthog/mcp/posthog_mcp.py b/posthog/mcp/posthog_mcp.py
index 49f892621..69951eade 100644
--- a/posthog/mcp/posthog_mcp.py
+++ b/posthog/mcp/posthog_mcp.py
@@ -773,10 +773,10 @@ def _inject_context(self, tool: Any, description: Optional[str]) -> Any:
         if self._is_sdk_virtual_tool(tool):
             return tool
         new_schema = add_context_parameter_to_schema(
-            getattr(tool, "inputSchema", None), name, description
+            _tool_schema(tool), name, description
         )
         try:
-            tool.inputSchema = new_schema
+            _set_tool_schema(tool, new_schema)
         except Exception:  # noqa: BLE001
             pass
         return tool
diff --git a/posthog/test/mcp/_helpers.py b/posthog/test/mcp/_helpers.py
index 836ef8ad6..4cfdbc5ff 100644
--- a/posthog/test/mcp/_helpers.py
+++ b/posthog/test/mcp/_helpers.py
@@ -59,6 +59,17 @@ def events_named(source, name):
     return [e for e in events if e["event"] == name]
 
 
+def structured_content(result):
+    """A ``CallToolResult``'s structured half: ``structuredContent`` on MCP SDK
+    1.x models, ``structured_content`` on 2.x (same wire field). Read the field
+    itself rather than the camelCase spelling, which 2.x only resolves once
+    standalone FastMCP 4's compatibility shim has been imported."""
+    for attr in ("structured_content", "structuredContent"):
+        if hasattr(result, attr):
+            return getattr(result, attr)
+    raise AssertionError("no structured content attribute")
+
+
 def listed_uris(response):
     """The uris a captured ``$mcp_resources_list`` response advertises, whether it
     listed static resources or templates."""
diff --git a/posthog/test/mcp/conftest.py b/posthog/test/mcp/conftest.py
index e17970c23..2806b6499 100644
--- a/posthog/test/mcp/conftest.py
+++ b/posthog/test/mcp/conftest.py
@@ -1,8 +1,9 @@
 """Split the MCP test suite by installed MCP SDK major.
 
 The suite runs against both majors in CI — the ``tests-mcp`` matrix has a
-``mcp>=1.26,<2`` leg and a ``mcp>=2,<3`` leg (the main ``tests`` matrix also
-exercises the v1 side incidentally). Files coupled to one
+``mcp>=1.26,<2`` leg and two ``mcp>=2,<3`` legs, with and without standalone
+FastMCP 4 (the main ``tests`` matrix also exercises the v1 side incidentally).
+Files coupled to one
 major's seams import symbols the other major doesn't ship, so they are excluded
 from *collection* (a skip marker can't help — the failure is at import time).
 Version-agnostic files (units, truncation, session tokens, PostHogMCP, ids)
diff --git a/posthog/test/mcp/test_output_instructions.py b/posthog/test/mcp/test_output_instructions.py
index bbef3c041..ecc064598 100644
--- a/posthog/test/mcp/test_output_instructions.py
+++ b/posthog/test/mcp/test_output_instructions.py
@@ -14,6 +14,7 @@
     can_declare_output_instructions,
     mirror_instructions_into_structured_content,
 )
+from posthog.test.mcp._helpers import structured_content
 
 
 def _tool(output_schema, name="demo"):
@@ -204,13 +205,6 @@ def test_mirror_does_not_mutate_a_shared_model_result():
     — and, through the handle, collapse unrelated clients into one session."""
     import mcp.types as mcp_types
 
-    # `structuredContent` on SDK 1.x, `structured_content` on 2.x (same wire field).
-    def structured(result):
-        for attr in ("structured_content", "structuredContent"):
-            if hasattr(result, attr):
-                return getattr(result, attr)
-        raise AssertionError("no structured content attribute")
-
     shared = mcp_types.CallToolResult(
         content=[mcp_types.TextContent(type="text", text="{}")],
         structuredContent={"total": 7},
@@ -220,9 +214,13 @@ def structured(result):
 
     assert delivered is True
     assert first is not shared  # a copy, not the caller's object
-    assert structured(first)[MCP_INSTRUCTIONS_KEY] == {"conversation_id": "conv-A"}
+    assert structured_content(first)[MCP_INSTRUCTIONS_KEY] == {
+        "conversation_id": "conv-A"
+    }
     # the shared object the customer owns is untouched, so the next caller is clean
-    assert MCP_INSTRUCTIONS_KEY not in structured(shared)
+    assert MCP_INSTRUCTIONS_KEY not in structured_content(shared)
 
     second, _ = mirror_instructions_into_structured_content(shared, "conv-B")
-    assert structured(second)[MCP_INSTRUCTIONS_KEY] == {"conversation_id": "conv-B"}
+    assert structured_content(second)[MCP_INSTRUCTIONS_KEY] == {
+        "conversation_id": "conv-B"
+    }
diff --git a/posthog/test/mcp/test_posthog_mcp.py b/posthog/test/mcp/test_posthog_mcp.py
index 6ed662e81..1251db910 100644
--- a/posthog/test/mcp/test_posthog_mcp.py
+++ b/posthog/test/mcp/test_posthog_mcp.py
@@ -20,6 +20,7 @@
 from posthog.test.mcp._helpers import (
     events_named as _events,
     flush_background as _flush,
+    structured_content,
 )
 from posthog.version import VERSION
 
@@ -262,6 +263,29 @@ def test_prepare_tool_list_injects_context_into_dicts():
     assert "context" not in tools[0]["inputSchema"]["properties"]
 
 
+@pytest.mark.parametrize("sdk_tool", [False, True])
+def test_prepare_tool_list_injects_context_into_tool_objects(sdk_tool: bool) -> None:
+    client, _ = make_client()
+    schema = {"type": "object", "properties": {"q": {"type": "string"}}}
+    tool = (
+        Tool(name="search", inputSchema=schema)
+        if sdk_tool
+        else SimpleNamespace(name="search", input_schema=schema)
+    )
+    schema_attribute = (
+        "input_schema" if hasattr(tool, "input_schema") else "inputSchema"
+    )
+
+    prepared = client.prepare_tool_list([tool])
+
+    advertised = getattr(prepared[0], schema_attribute)
+    assert "context" in advertised["properties"]
+    assert "context" in advertised["required"]
+    assert "q" in advertised["properties"]
+    # the caller's schema dict is untouched
+    assert "context" not in schema["properties"]
+
+
 def test_prepare_tool_list_can_be_disabled():
     client, _ = make_client()
     tools = [{"name": "search", "inputSchema": {"type": "object", "properties": {}}}]
@@ -602,7 +626,7 @@ def test_prepare_tool_result_delivers_into_call_tool_result_models(wrapped):
     delivered = prepared.result.root if wrapped else prepared.result
     assert len(call_result.content) == 1
     assert delivered.content[-1].text == _handle_block(prepared.conversation_id)["text"]
-    assert delivered.structuredContent[MCP_INSTRUCTIONS_KEY] == {
+    assert structured_content(delivered)[MCP_INSTRUCTIONS_KEY] == {
         "conversation_id": prepared.conversation_id
     }
     assert _UUID7.match(prepared.conversation_id)

From 9f5d4586083c070cf800860530a068c2f3353c08 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 3 Nov 2026 13:59:22 +0000
Subject: [PATCH 172/245] chore: Release v7.83.1 [skip ci]

---
 .sampo/changesets/bold-lord-hiisi.md | 5 -----
 openfeature-provider/CHANGELOG.md    | 6 ++++++
 openfeature-provider/pyproject.toml  | 2 +-
 posthog/CHANGELOG.md                 | 6 ++++++
 posthog/version.py                   | 2 +-
 pyproject.toml                       | 2 +-
 uv.lock                              | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/bold-lord-hiisi.md

diff --git a/.sampo/changesets/bold-lord-hiisi.md b/.sampo/changesets/bold-lord-hiisi.md
deleted file mode 100644
index 422365623..000000000
--- a/.sampo/changesets/bold-lord-hiisi.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-`PostHogMCP.prepare_tool_list` now adds the `context` argument to MCP SDK 2.x `Tool` objects. It only added it to dicts and 1.x `Tool` objects before, so `$mcp_intent` was never captured for 2.x tool objects.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 1c1793814..d665cae6f 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.142 — 2026-11-03
+
+### Patch changes
+
+- Updated dependencies: posthog@7.83.1
+
 ## 0.1.141 — 2026-11-03
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 59ecaa1d1..45213d144 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.141"
+version = "0.1.142"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 631a7caac..9d3f8ad37 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.83.1 — 2026-11-03
+
+### Patch changes
+
+- [0c12ca1](https://github.com/posthog/posthog-python/commit/0c12ca1521f6538873e00f5240cad306c9bba455) `PostHogMCP.prepare_tool_list` now adds the `context` argument to MCP SDK 2.x `Tool` objects. It only added it to dicts and 1.x `Tool` objects before, so `$mcp_intent` was never captured for 2.x tool objects. — Thanks @connor-grady!
+
 ## 7.83.0 — 2026-11-03
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 36d7c0455..3d6336f75 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.83.0"
+VERSION = "7.83.1"
diff --git a/pyproject.toml b/pyproject.toml
index 990c0c6a3..d13cde587 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.83.0"
+version = "7.83.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 2c945cc7d..83c4611c2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.141"
+version = "0.1.142"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.83.0"
+version = "7.83.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 06e56118d02ba692fbb0427d2044eb2d4d927250 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 3 Nov 2026 13:59:27 +0000
Subject: [PATCH 173/245] Update generated references

---
 .../posthog-python-references-7.83.1.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.83.1.json

diff --git a/references/posthog-python-references-7.83.1.json b/references/posthog-python-references-7.83.1.json
new file mode 100644
index 000000000..a2d0c5a3e
--- /dev/null
+++ b/references/posthog-python-references-7.83.1.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.83.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index ea89d2637..a2d0c5a3e 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.83.0",
+    "version": "7.83.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From ff90d0bfd07d1285cd9e834ff0e6df7c75e68e27 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Wed, 4 Nov 2026 09:17:44 -0500
Subject: [PATCH 174/245] docs(examples): update Anthropic examples to
 claude-sonnet-5-5 (#1173)

* docs(examples): update Anthropic examples to claude-sonnet-5-5

* docs(examples): show summarized thinking in the extended thinking example
---
 examples/example-ai-anthropic/chat.py              | 2 +-
 examples/example-ai-anthropic/extended_thinking.py | 4 ++--
 examples/example-ai-anthropic/streaming.py         | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/example-ai-anthropic/chat.py b/examples/example-ai-anthropic/chat.py
index 9a17424e3..c8a024070 100644
--- a/examples/example-ai-anthropic/chat.py
+++ b/examples/example-ai-anthropic/chat.py
@@ -58,7 +58,7 @@ def get_weather(latitude: float, longitude: float, location_name: str) -> str:
 
 
 message = client.messages.create(
-    model="claude-sonnet-4-5-20250929",
+    model="claude-sonnet-5-5",
     max_tokens=1024,
     tools=tools,
     messages=[{"role": "user", "content": "What's the weather like in San Francisco?"}],
diff --git a/examples/example-ai-anthropic/extended_thinking.py b/examples/example-ai-anthropic/extended_thinking.py
index 7254c6904..cfc445e1f 100644
--- a/examples/example-ai-anthropic/extended_thinking.py
+++ b/examples/example-ai-anthropic/extended_thinking.py
@@ -34,9 +34,9 @@
 client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
 
 message = client.messages.create(
-    model="claude-sonnet-4-5-20250929",
+    model="claude-sonnet-5-5",
     max_tokens=16000,
-    thinking={"type": "enabled", "budget_tokens": 10000},
+    thinking={"type": "adaptive", "display": "summarized"},
     messages=[
         {
             "role": "user",
diff --git a/examples/example-ai-anthropic/streaming.py b/examples/example-ai-anthropic/streaming.py
index ea8c884b1..7bbe8d082 100644
--- a/examples/example-ai-anthropic/streaming.py
+++ b/examples/example-ai-anthropic/streaming.py
@@ -31,7 +31,7 @@
 client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
 
 stream = client.messages.create(
-    model="claude-sonnet-4-5-20250929",
+    model="claude-sonnet-5-5",
     max_tokens=1024,
     messages=[{"role": "user", "content": "Write a haiku about observability."}],
     stream=True,

From ae2dcf2eaa76fa2693ed8ebe19bbf22054661acb Mon Sep 17 00:00:00 2001
From: Shy Alter <puemos@users.noreply.github.com>
Date: Wed, 4 Nov 2026 20:14:52 +0100
Subject: [PATCH 175/245] fix(flags): respect feature enrollment in local
 evaluation (#1176)

* fix(flags): respect feature enrollment in local evaluation

A flag with early access feature enrollment now uses the $feature_enrollment/<flag key> person property when it is passed, like the flags service. Without it, local evaluation is inconclusive (missing_context) and falls back to /flags, instead of returning a certain False for enrolled people.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: fecca688-37ac-44b6-a1b5-27e11cb0749b

* fix(flags): match the flags service enrollment values exactly

Check enrollment only when feature_enrollment is boolean true, and treat only true or "true" as enrolled, like the flags service. A value such as 1 now reads as opted out instead of enrolled.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: fecca688-37ac-44b6-a1b5-27e11cb0749b

* fix(flags): send group flags with feature enrollment to the flags service

For a group flag, local evaluation passes group properties, but the flags service reads enrollment from the person. Local evaluation now treats a group flag with feature enrollment as unresolved, so it falls back to /flags.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Generated-By: PostHog Desktop
Task-Id: fecca688-37ac-44b6-a1b5-27e11cb0749b
---
 .../local-eval-feature-enrollment.md          |  5 ++
 posthog/feature_flags.py                      | 15 ++++
 posthog/test/test_feature_flags.py            | 72 +++++++++++++++++++
 3 files changed, 92 insertions(+)
 create mode 100644 .sampo/changesets/local-eval-feature-enrollment.md

diff --git a/.sampo/changesets/local-eval-feature-enrollment.md b/.sampo/changesets/local-eval-feature-enrollment.md
new file mode 100644
index 000000000..9c9f98fe6
--- /dev/null
+++ b/.sampo/changesets/local-eval-feature-enrollment.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Local evaluation now respects early access feature enrollment. A flag with feature enrollment uses the `$feature_enrollment/<flag key>` person property when you pass it, and otherwise falls back to the flags service. Before, it returned `False` for enrolled people who matched no release condition, while the flags service returned `True`.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index cfe847fbb..6a16ee319 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -492,6 +492,21 @@ def match_feature_flag_properties(
 
     flag_filters = flag.get("filters") or {}
 
+    if flag_filters.get("feature_enrollment") is True:
+        enrollment_key = f"$feature_enrollment/{flag.get('key')}"
+        if flag_filters.get("aggregation_group_type_index") is not None:
+            raise InconclusiveMatchError(
+                "Group flag has feature enrollment, which reads person properties",
+                reason=UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            )
+        if enrollment_key not in properties:
+            raise InconclusiveMatchError(
+                f"Flag has feature enrollment and '{enrollment_key}' was not passed",
+                reason=UnresolvedFlagReason.MISSING_CONTEXT,
+            )
+        enrollment = properties[enrollment_key]
+        return enrollment is True or enrollment == "true"
+
     # Holdouts are evaluated before release conditions, so a held-out value is excluded
     # from the flag's targeting entirely rather than being bucketed into a variant.
     holdout_variant = _get_holdout_variant(flag, bucketing_value)
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index eb89117b1..ff1d56593 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -1192,6 +1192,78 @@ def test_experience_continuity_flag_not_evaluated_locally(self, patch_flags):
         )
         self.assertEqual(patch_flags.call_count, 1)
 
+    @parameterized.expand(
+        [
+            ("enrollment not passed", {}, 0, "flags-fallback-value", 1, False),
+            (
+                "enrolled",
+                {"$feature_enrollment/beta-feature": "true"},
+                0,
+                True,
+                0,
+                False,
+            ),
+            (
+                "opted out",
+                {"$feature_enrollment/beta-feature": False},
+                100,
+                False,
+                0,
+                False,
+            ),
+            (
+                "not a true value",
+                {"$feature_enrollment/beta-feature": 1},
+                100,
+                False,
+                0,
+                False,
+            ),
+            (
+                "group flag",
+                {"$feature_enrollment/beta-feature": False},
+                100,
+                "flags-fallback-value",
+                1,
+                True,
+            ),
+        ]
+    )
+    def test_feature_enrollment_flag(
+        self, _name, person_properties, rollout, expected, flags_calls, group
+    ):
+        client = Client(FAKE_TEST_API_KEY, secret_key="test")
+        client.feature_flags = [
+            {
+                "id": 1,
+                "key": "beta-feature",
+                "active": True,
+                "filters": {
+                    "groups": [{"properties": [], "rollout_percentage": rollout}],
+                    "feature_enrollment": True,
+                    "aggregation_group_type_index": 0 if group else None,
+                },
+            }
+        ]
+        client.group_type_mapping = {"0": "company"}
+        with mock.patch("posthog.client.flags") as patch_flags:
+            patch_flags.return_value = {
+                "featureFlags": {"beta-feature": "flags-fallback-value"}
+            }
+            value = client.get_feature_flag(
+                "beta-feature",
+                "distinct_id",
+                person_properties=person_properties,
+                groups={"company": "acme"} if group else None,
+                group_properties={
+                    "company": {"$feature_enrollment/beta-feature": "true"}
+                }
+                if group
+                else None,
+            )
+
+        self.assertEqual((value, patch_flags.call_count), (expected, flags_calls))
+
     @mock.patch.object(Client, "capture")
     @mock.patch("posthog.client.flags")
     def test_get_all_flags_with_fallback(self, patch_flags, patch_capture):

From d8571c36800d72ba3317dbb062ef03a252a484d0 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 4 Nov 2026 20:19:58 +0000
Subject: [PATCH 176/245] chore: Release v7.83.2 [skip ci]

---
 .sampo/changesets/local-eval-feature-enrollment.md | 5 -----
 openfeature-provider/CHANGELOG.md                  | 6 ++++++
 openfeature-provider/pyproject.toml                | 2 +-
 posthog/CHANGELOG.md                               | 6 ++++++
 posthog/version.py                                 | 2 +-
 pyproject.toml                                     | 2 +-
 uv.lock                                            | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/local-eval-feature-enrollment.md

diff --git a/.sampo/changesets/local-eval-feature-enrollment.md b/.sampo/changesets/local-eval-feature-enrollment.md
deleted file mode 100644
index 9c9f98fe6..000000000
--- a/.sampo/changesets/local-eval-feature-enrollment.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Local evaluation now respects early access feature enrollment. A flag with feature enrollment uses the `$feature_enrollment/<flag key>` person property when you pass it, and otherwise falls back to the flags service. Before, it returned `False` for enrolled people who matched no release condition, while the flags service returned `True`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index d665cae6f..c2e9dac84 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.143 — 2026-11-04
+
+### Patch changes
+
+- Updated dependencies: posthog@7.83.2
+
 ## 0.1.142 — 2026-11-03
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 45213d144..5edc15535 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.142"
+version = "0.1.143"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 9d3f8ad37..730ce2105 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.83.2 — 2026-11-04
+
+### Patch changes
+
+- [ae2dcf2](https://github.com/posthog/posthog-python/commit/ae2dcf2eaa76fa2693ed8ebe19bbf22054661acb) Local evaluation now respects early access feature enrollment. A flag with feature enrollment uses the `$feature_enrollment/<flag key>` person property when you pass it, and otherwise falls back to the flags service. Before, it returned `False` for enrolled people who matched no release condition, while the flags service returned `True`. — Thanks @puemos for your first contribution 🎉!
+
 ## 7.83.1 — 2026-11-03
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 3d6336f75..085987217 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.83.1"
+VERSION = "7.83.2"
diff --git a/pyproject.toml b/pyproject.toml
index d13cde587..83af0d71c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.83.1"
+version = "7.83.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 83c4611c2..67deb9c1c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.142"
+version = "0.1.143"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.83.1"
+version = "7.83.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 2c0958237fe28f73edfbe2bef3bfe2c7db4b7b9a Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 4 Nov 2026 20:20:04 +0000
Subject: [PATCH 177/245] Update generated references

---
 .../posthog-python-references-7.83.2.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.83.2.json

diff --git a/references/posthog-python-references-7.83.2.json b/references/posthog-python-references-7.83.2.json
new file mode 100644
index 000000000..8962f1f55
--- /dev/null
+++ b/references/posthog-python-references-7.83.2.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.83.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index a2d0c5a3e..8962f1f55 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.83.1",
+    "version": "7.83.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 7e1afec55b00226a7a3b789cac7c4d6f068e202d Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Wed, 4 Nov 2026 16:07:10 -0500
Subject: [PATCH 178/245] ci: add paired Python SDK performance benchmarks
 (#1134)

* ci: add paired Python SDK performance benchmarks

* fix: bound benchmark timeouts and clean killed worker profiles
---
 .github/workflows/benchmarks.yml |  90 +++++++
 .gitignore                       |   1 +
 benchmarks/README.md             | 117 +++++++++
 benchmarks/fixtures.py           | 209 ++++++++++++++++
 benchmarks/identity.py           |  45 ++++
 benchmarks/measurement.py        |  85 +++++++
 benchmarks/prepare.py            |  81 +++++++
 benchmarks/requirements.in       |   3 +
 benchmarks/requirements.txt      | 291 +++++++++++++++++++++++
 benchmarks/run.py                | 395 +++++++++++++++++++++++++++++++
 benchmarks/server.py             | 119 ++++++++++
 benchmarks/test_benchmarks.py    | 387 ++++++++++++++++++++++++++++++
 benchmarks/worker.py             |  96 ++++++++
 benchmarks/workload.py           | 171 +++++++++++++
 14 files changed, 2090 insertions(+)
 create mode 100644 .github/workflows/benchmarks.yml
 create mode 100644 benchmarks/README.md
 create mode 100644 benchmarks/fixtures.py
 create mode 100644 benchmarks/identity.py
 create mode 100644 benchmarks/measurement.py
 create mode 100644 benchmarks/prepare.py
 create mode 100644 benchmarks/requirements.in
 create mode 100644 benchmarks/requirements.txt
 create mode 100644 benchmarks/run.py
 create mode 100644 benchmarks/server.py
 create mode 100644 benchmarks/test_benchmarks.py
 create mode 100644 benchmarks/worker.py
 create mode 100644 benchmarks/workload.py

diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
new file mode 100644
index 000000000..eecd98490
--- /dev/null
+++ b/.github/workflows/benchmarks.yml
@@ -0,0 +1,90 @@
+name: Python SDK benchmarks
+
+on:
+    pull_request:
+        paths:
+            - 'posthog/**'
+            - 'benchmarks/**'
+            - 'pyproject.toml'
+            - 'setup.py'
+            - 'uv.lock'
+            - '.github/workflows/benchmarks.yml'
+
+permissions: {}
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+    cancel-in-progress: true
+
+jobs:
+    benchmark:
+        runs-on: ubuntu-24.04
+        timeout-minutes: 30
+        permissions:
+            contents: read
+        steps:
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+              with:
+                  ref: ${{ github.event.pull_request.head.sha }}
+                  fetch-depth: 0
+                  persist-credentials: false
+
+            - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              with:
+                  python-version: '3.12.12'
+
+            - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              with:
+                  version: '0.13.4'
+                  enable-cache: true
+
+            - name: Prepare pinned baseline
+              env:
+                  TARGET_SHA: ${{ github.event.pull_request.base.sha }}
+                  HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+              run: |
+                  set -euo pipefail
+                  export BASE_WORKTREE="$RUNNER_TEMP/python-benchmark-base"
+                  export RESULTS="$RUNNER_TEMP/python-benchmark-results"
+                  printf 'BASE_WORKTREE=%s\nRESULTS=%s\n' "$BASE_WORKTREE" "$RESULTS" >> "$GITHUB_ENV"
+                  BASE_SHA=$(git merge-base "$TARGET_SHA" "$HEAD_SHA")
+                  git worktree add --detach "$BASE_WORKTREE" "$BASE_SHA"
+                  mkdir -p "$RESULTS"
+                  python -c 'import json, os, pathlib, sys; pathlib.Path(os.environ["RESULTS"], "revisions.json").write_text(json.dumps({"target":os.environ["TARGET_SHA"], "head":os.environ["HEAD_SHA"], "base":sys.argv[1]}, indent=2))' "$BASE_SHA"
+
+            - name: Install isolated head and baseline wheels
+              run: |
+                  python benchmarks/prepare.py .
+                  python benchmarks/prepare.py "$BASE_WORKTREE"
+
+            - name: Test measurement controls and fixtures
+              run: .venv-benchmark/bin/python -B benchmarks/test_benchmarks.py
+
+            - name: Measure paired base and head
+              run: |
+                  .venv-benchmark/bin/python -B benchmarks/run.py \
+                    --base "$BASE_WORKTREE" \
+                    --head "$GITHUB_WORKSPACE" \
+                    --output "$RESULTS" \
+                    --repetitions 6
+
+            - name: Upload raw benchmark results
+              if: always()
+              id: results
+              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              with:
+                  name: python-benchmark-results
+                  path: ${{ runner.temp }}/python-benchmark-results
+                  if-no-files-found: warn
+                  retention-days: 14
+
+            - name: Link results
+              if: always()
+              env:
+                  ARTIFACT_URL: ${{ steps.results.outputs.artifact-url }}
+              run: |
+                  printf '## Python SDK benchmark data\n\n' >> "$GITHUB_STEP_SUMMARY"
+                  if [[ -n "$ARTIFACT_URL" ]]; then
+                    printf '[Download paired measurements and execution metadata](%s)\n\n' "$ARTIFACT_URL" >> "$GITHUB_STEP_SUMMARY"
+                  fi
+                  printf 'Measurements are informational. Check workload statuses before comparing values.\n' >> "$GITHUB_STEP_SUMMARY"
diff --git a/.gitignore b/.gitignore
index 42fbc82dd..b8e7cb9ac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ build/
 env/
 venv/
 .venv/
+.venv-benchmark/
 flake8.out
 pylint.out
 posthog-analytics
diff --git a/benchmarks/README.md b/benchmarks/README.md
new file mode 100644
index 000000000..8ca37a758
--- /dev/null
+++ b/benchmarks/README.md
@@ -0,0 +1,117 @@
+# Python SDK benchmarks
+
+PR-only, paired measurements of independently installed Python SDK revisions. Each workload/pass/repetition runs in a fresh process against the target's non-editable wheel. Benchmark code comes from one checkout and emits `base.json` and `head.json` in the Node pilot's result structure.
+
+## Setup and local execution
+
+Use **CPython 3.12.12** and **uv 0.13.4**, matching `.github/workflows/benchmarks.yml`.
+
+From the checkout containing this suite, prepare each revision:
+
+```sh
+python benchmarks/prepare.py /absolute/path/to/head
+python benchmarks/prepare.py /absolute/path/to/base
+```
+
+Each target gets its own `.venv-benchmark`. Preparation installs the SDK and runtime dependencies from that revision's frozen `uv.lock`, builds a non-editable SDK wheel, then installs hash-pinned benchmark instrumentation from this suite's `requirements.txt`. Preparation fails if instrumentation changes an already installed SDK dependency version. Both environments precompile bytecode: importing cached bytecode on one side and compiling source on the other can otherwise create an apparent RSS regression even with identical SDK source. Workers do not write new bytecode. The benchmark environment is disposable and separate from the ordinary development `.venv`.
+
+Run the controls and benchmarks using the head environment:
+
+```sh
+.venv-benchmark/bin/python -B benchmarks/test_benchmarks.py
+.venv-benchmark/bin/python -B benchmarks/run.py \
+  --base /absolute/path/to/base \
+  --head /absolute/path/to/head \
+  --output /tmp/python-benchmark-results \
+  --repetitions 6
+```
+
+`--smoke --repetitions 1` checks integration quickly; smoke results are not suitable for performance conclusions. `--filter flags.all.` selects workload IDs by prefix. Using the same revision on both sides measures repeatability, not an improvement.
+
+Rerun preparation after changing SDK source. Preparation forces a `posthog` rebuild/reinstall so source-only changes cannot reuse uv's cached wheel. The worker deliberately does not import the repository source tree. Results fingerprint the installed package's Python files and record its entry path, SDK commit/dirty state, package version, lockfile digest, actual installed dependency/tool versions, benchmark source digest, runtime, fixture digest, and paired-run ID.
+
+To update benchmark tooling, use a supported uv version and review the regenerated lock:
+
+```sh
+uv pip compile benchmarks/requirements.in --python-version 3.12 --universal \
+  --generate-hashes --exclude-newer '7 days' --output-file benchmarks/requirements.txt
+```
+
+## Workloads
+
+| Workload | Public path | Measurements |
+| --- | --- | --- |
+| Nine single-flag cases | `get_feature_flag` | Elapsed time/op, process CPU/op, Python allocator bytes/calls per op |
+| All flags: 10, 100, 1,000 | `get_all_flags` | Same metrics per complete all-flags call |
+| Sustained 1,000-flag evaluation | Eight threads calling `get_all_flags` | RSS observations and post-settling RSS |
+| Forty definition refreshes | `load_feature_flags`, then validated `get_all_flags` | Memory checkpoints every five cycles and at the end |
+| Capture: 32-byte and 4,096-byte string properties | `capture` | Foreground elapsed time and caller-thread CPU per event |
+| Capture and drain: both payload sizes | `capture`, `flush` every 100 events | Full-pipeline time, process CPU, allocator bytes/calls, and memory |
+
+The flag mix and sixteen identities match the Node pilot conceptually: boolean, percentage rollout, multivariate assignment, person properties, regex, cohort, early/late/no-match, and inactive flags. Expected values are computed independently of the SDK. Every identity is validated before and after measurement. Refresh generations alter actual boolean/cohort results and regex patterns so a fetch without a state update fails validation.
+
+The suite covers the supported legacy flag getters, not `evaluate_flags` snapshots. Deprecation warnings are encountered during setup. Eight threads are **GIL-constrained concurrency**, not a claim of eight-way parallel Python execution.
+
+### Transport and lifecycle
+
+Python has no public fetch adapter. A bounded loopback HTTP server runs in the coordinator process, outside the measured worker, and serves definitions and accepts uncompressed v0 batches. Its routes are limited to the fixture protocol and a control/inspection interface. It retains counters and per-identity counts, not event history. Remote flag fallback is unexpected and fails verification.
+
+The SDK uses real requests, JSON parsing/serialization, background consumers, flag loading, flush, and shutdown. No private queue, evaluator, or poller is replaced. Automatic polling and partial-batch deadlines are set to one hour, longer than the worker timeout. Refreshes and draining use public methods. Worker shutdown must stop SDK threads.
+
+Capture checks require the correct event name, exact payload, identity distribution, and total delivered count. Rejected captures, timeouts that leave undelivered events, malformed payloads, and remote fallback cannot appear as successful low-cost work.
+
+### Capture measurement boundaries
+
+`capture()` returns after foreground preparation/enqueue, while a consumer can concurrently prepare its batch. There is no public completion boundary for that background preparation short of flushing. Therefore:
+
+- `capture.enqueue.*` reports foreground elapsed time and **caller-thread CPU**, not process-wide CPU or allocation totals.
+- `capture.drain.*` includes `flush(timeout_seconds=None)` and reports the complete delivery path's process CPU and allocations, including requests/serialization. The external worker timeout bounds this wait. Verification does not flush again: unfinished measured work cannot be rescued outside the measurement. Server CPU and server allocations are excluded; elapsed time includes loopback transport.
+- Enqueue-only allocation metrics are explicitly unavailable and direct readers to the drain workload.
+
+The enqueue workload uses 1,000 events, below queue/batch-count limits; partial batches can still be prepared by the consumer. These metrics describe their named paths rather than pretending Python and Node have identical asynchronous lifecycles.
+
+## Measurement methods
+
+Base/head alternate first position between independent repetitions and never benchmark concurrently. The same head-side fixtures and measurement code run against both installations. The runner verifies matching Python, profiler, psutil, OS, and architecture versions. Both workers use a fixed hash seed and a clean Python configuration environment.
+
+Warmup and correctness checks happen outside timing. Timing, allocation profiling, and memory observation are separate passes. Allocation passes use smaller fixed operation counts where tracing every Python allocation would otherwise produce excessive profiler files; the actual count is included in each result and used as its denominator. These counts are identical for base and head.
+
+### Time and CPU
+
+- `elapsed_time_per_op`: `time.perf_counter_ns`, normalized over a batch.
+- `process_cpu_time_per_op`: `time.process_time_ns`, including all worker threads.
+- `caller_thread_cpu_time_per_op`: `time.thread_time_ns`, for foreground enqueue only.
+
+The metrics include the small benchmark-loop overhead. Elapsed time is not CPU utilization.
+
+### Allocations
+
+Memray runs with `trace_python_allocators=True` and `FileFormat.ALL_ALLOCATIONS`. After tracking stops, the adapter streams all records and sums `PYMALLOC_MALLOC`, `PYMALLOC_CALLOC`, and `PYMALLOC_REALLOC` requests. This includes requests whose allocations were already freed. It excludes free records and native backing allocations, avoiding interpreting backing arenas as individual Python allocations.
+
+- `allocated_bytes_per_op` is cumulative **requested Python allocator bytes**. A reallocation contributes its requested size, not just its growth.
+- `allocations_per_op` is **Python allocator calls, including reallocations**, not a count of distinct Python objects.
+- Both are measured counters, unlike Node's estimated V8 allocation bytes. They are still not cross-language-comparable totals.
+- Native-library allocations outside Python's allocators are not included. RSS covers the whole process.
+
+Profiler capture and aggregation do not contribute to reported timing. Profiles are streamed and removed after aggregation so repeated runs do not retain large binary captures. Raw counters and profiler versions remain in the JSON.
+
+The control suite demonstrates that this configuration records freed small allocations that default Memray tracking does not expose as Python allocator requests. Other controls preserve SDK outputs while adding CPU work and allocation churn; both must be detected. See [Memray's allocator documentation](https://bloomberg.github.io/memray/python_allocators.html) and [API documentation](https://bloomberg.github.io/memray/api.html).
+
+### Memory
+
+- Idle RSS: after imports, definitions, validation, warmup, and settling.
+- Observed workload peak RSS: operation checkpoints and end-of-work observation; can miss intervening spikes.
+- Lifetime peak RSS: `resource.getrusage`, normalized from platform-specific units. Includes setup and warmup, not just measured work.
+- Post-settling RSS: after two `gc.collect()` calls separated by a scheduler yield. Python reference counting also frees objects during ordinary execution.
+
+CPython has no uninstrumented total managed-heap byte counter equivalent to Node's `heapUsed`. `post_settling_heap_used` is explicitly unsupported; enabling tracing in the RSS pass would change the measurement. Retained RSS alone does not prove a leak because allocators can keep arenas resident. A public-entry control deliberately retains 8 MiB on each refresh and verifies that post-GC checkpoints expose the growth.
+
+Each worker has a two-minute timeout and an externally monitored **512 MiB RSS ceiling**, checked approximately every 20 ms. This is a safety bound, not an exact OS-enforced limit: short spikes can exceed it between observations. A ceiling violation is reported as `error` with `rss_limit_exceeded`, not falsely described as a confirmed OS OOM. An explicit Python `MemoryError` is classified as OOM; a generic kill is not. The suite stops after two worker timeouts, after completing the current base/head pair, and preserves partial results for upload. Worker temporary files, including profiler traces, are owned and removed by the coordinator even when a worker is killed.
+
+## Results and CI
+
+The pilot JSON format uses `schema_version: 1`, with the same top-level revision, suite, execution, benchmark, metric, sample, and status structure as Node. Measurement IDs, units, method names, and quality are explicit. Python's intentional differences are allocator-call counts, foreground-thread CPU for enqueue, unavailable uninstrumented heap size, and a separate HTTP receiver. Shared schema finalization and rendering are separate work.
+
+The PR workflow builds the merge base and exact head into isolated environments, then runs this head-side suite against both. It requests read-only permissions, uses pinned actions, requires no service credentials, preserves partial results after worker failures, and uploads JSON artifacts linked from the job summary.
+
+Correctness failures and broken execution fail the job. Performance differences do not: this producer does not compute regression verdicts. Shared comparisons, noise classification, and PR comments remain separate. Calibrate on the actual Linux runner before introducing performance gates; local macOS results are not a CI noise floor.
diff --git a/benchmarks/fixtures.py b/benchmarks/fixtures.py
new file mode 100644
index 000000000..a59599584
--- /dev/null
+++ b/benchmarks/fixtures.py
@@ -0,0 +1,209 @@
+"""Deterministic fixtures matching the Node pilot's flag mix and identities."""
+
+import hashlib
+import json
+from typing import Any
+
+CASES = [
+    "boolean",
+    "rollout",
+    "variant",
+    "property",
+    "regex",
+    "cohort",
+    "early",
+    "late",
+    "no-match",
+    "inactive",
+]
+USERS = [
+    {
+        "distinct_id": f"benchmark-user-{i}",
+        "person_properties": {
+            "plan": "free" if i % 2 else "pro",
+            "email": f"user-{i}@example.test",
+            "score": i,
+        },
+    }
+    for i in range(16)
+]
+
+
+def prop(key, value, operator="exact"):
+    return {"key": key, "value": value, "operator": operator, "type": "person"}
+
+
+def group(properties=None, rollout=100):
+    return {"properties": properties or [], "rollout_percentage": rollout}
+
+
+def definitions(count, generation=0):
+    flags = []
+    for i in range(count):
+        kind = CASES[i % len(CASES)]
+        match = group([prop("plan", ["pro"])])
+        miss = group([prop("plan", ["never"])])
+        groups = [group()]
+        if kind == "rollout":
+            groups = [group(rollout=50)]
+        elif kind == "property":
+            groups = [match]
+        elif kind == "regex":
+            groups = [
+                group(
+                    [
+                        prop(
+                            "email",
+                            f"^(user|refresh-{generation})-[0-9]+@example[.]test$",
+                            "regex",
+                        )
+                    ]
+                )
+            ]
+        elif kind == "cohort":
+            groups = [group([{"key": "id", "value": 1, "type": "cohort"}])]
+        elif kind == "early":
+            groups = [match] + [miss] * 7
+        elif kind == "late":
+            groups = [miss] * 7 + [match]
+        elif kind == "no-match":
+            groups = [miss] * 8
+        filters: dict[str, Any] = {"groups": groups}
+        if kind == "variant":
+            filters["multivariate"] = {
+                "variants": [
+                    {"key": "control", "rollout_percentage": 50},
+                    {"key": "test", "rollout_percentage": 50},
+                ]
+            }
+        flags.append(
+            {
+                "id": i + 1,
+                "key": f"{kind}-{i}",
+                "name": f"{kind}-{i}",
+                "active": kind != "inactive"
+                and (kind != "boolean" or generation % 2 == 0),
+                "filters": filters,
+            }
+        )
+    return {
+        "flags": flags,
+        "group_type_mapping": {},
+        "cohorts": {
+            "1": {
+                "type": "AND",
+                "values": [
+                    prop("plan", ["pro"]),
+                    prop("score", 100 if generation % 2 else -1, "gt"),
+                ],
+            },
+        },
+    }
+
+
+def bucket(key, distinct_id, salt=""):
+    return int(
+        hashlib.sha1(f"{key}.{distinct_id}{salt}".encode()).hexdigest()[:15], 16
+    ) / (2**60 - 1)
+
+
+def expected_value(index, user, generation=0):
+    kind = CASES[index % len(CASES)]
+    key = f"{kind}-{index}"
+    if kind == "rollout":
+        return bucket(key, user["distinct_id"]) < 0.5
+    if kind == "variant":
+        return (
+            "control" if bucket(key, user["distinct_id"], "variant") < 0.5 else "test"
+        )
+    if kind == "boolean":
+        return generation % 2 == 0
+    if kind == "cohort" and generation % 2:
+        return False
+    if kind in ("property", "cohort", "early", "late"):
+        return user["person_properties"]["plan"] == "pro"
+    return kind not in ("inactive", "no-match")
+
+
+def expected_flags(count, user, generation=0):
+    return {
+        f"{CASES[i % len(CASES)]}-{i}": expected_value(i, user, generation)
+        for i in range(count)
+    }
+
+
+def digest(value):
+    data = (
+        value
+        if isinstance(value, bytes)
+        else json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+    )
+    return hashlib.sha256(data).hexdigest()
+
+
+def workloads(smoke=False):
+    return [
+        *[
+            {
+                "id": f"flags.single.{kind}",
+                "mode": "single",
+                "flag_count": 10,
+                "flag_index": i,
+                "operations": 160 if smoke else 16000,
+                "allocation_operations": 160 if smoke else 2000,
+                "concurrency": 1,
+                "passes": ["timing", "allocation"],
+            }
+            for i, kind in enumerate(CASES[:9])
+        ],
+        *[
+            {
+                "id": f"flags.all.{count}",
+                "mode": "all",
+                "flag_count": count,
+                "operations": 16 if smoke else max(160, 16000 // count),
+                "allocation_operations": 16 if smoke else max(16, 1600 // count),
+                "concurrency": 1,
+                "passes": ["timing", "allocation"],
+            }
+            for count in (10, 100, 1000)
+        ],
+        {
+            "id": "flags.load.1000",
+            "mode": "all",
+            "flag_count": 1000,
+            "operations": 32 if smoke else 1600,
+            "concurrency": 8,
+            "passes": ["memory"],
+        },
+        {
+            "id": "flags.refresh.1000",
+            "mode": "refresh",
+            "flag_count": 1000,
+            "operations": 4 if smoke else 40,
+            "concurrency": 1,
+            "passes": ["memory"],
+        },
+        *[
+            {
+                "id": f"capture.enqueue.{size}",
+                "mode": "capture",
+                "payload_bytes": size,
+                "operations": 100 if smoke else 1000,
+                "concurrency": 1,
+                "passes": ["timing"],
+            }
+            for size in (32, 4096)
+        ],
+        *[
+            {
+                "id": f"capture.drain.{size}",
+                "mode": "drain",
+                "payload_bytes": size,
+                "operations": 200 if smoke else 1000,
+                "concurrency": 1,
+                "passes": ["timing", "allocation", "memory"],
+            }
+            for size in (32, 4096)
+        ],
+    ]
diff --git a/benchmarks/identity.py b/benchmarks/identity.py
new file mode 100644
index 000000000..6e77152b8
--- /dev/null
+++ b/benchmarks/identity.py
@@ -0,0 +1,45 @@
+import importlib.metadata
+import platform
+import sys
+from pathlib import Path
+
+from fixtures import digest
+
+
+def source_digest(directory):
+    directory = Path(directory)
+    return digest(
+        {
+            str(path.relative_to(directory)): digest(path.read_bytes())
+            for path in sorted(directory.rglob("*"))
+            if path.is_file()
+            and path.suffix in (".py", ".txt", ".in")
+            and "__pycache__" not in path.parts
+        }
+    )
+
+
+def environment():
+    import posthog
+
+    entry = Path(posthog.__file__).resolve()
+    if not entry.is_relative_to(Path(sys.prefix)):
+        raise RuntimeError(f"Expected installed SDK inside {sys.prefix}, got {entry}")
+    packages = {
+        dist.metadata["Name"].lower().replace("_", "-"): dist.version
+        for dist in importlib.metadata.distributions()
+    }
+    return {
+        "runtime": "cpython",
+        "runtime_version": platform.python_version(),
+        "implementation": sys.version,
+        "os": sys.platform,
+        "arch": platform.machine(),
+        "kernel": platform.release(),
+        "cpu": platform.processor(),
+        "entry": str(entry),
+        "build_digest": source_digest(entry.parent),
+        "packages": packages,
+        "sdk_version": importlib.metadata.version("posthog"),
+        "measurement_tools": {name: packages[name] for name in ("memray", "psutil")},
+    }
diff --git a/benchmarks/measurement.py b/benchmarks/measurement.py
new file mode 100644
index 000000000..d79875e17
--- /dev/null
+++ b/benchmarks/measurement.py
@@ -0,0 +1,85 @@
+"""Process measurements; allocation instrumentation never runs in a timing/RSS pass."""
+
+import gc
+import resource
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import psutil
+
+PROCESS = psutil.Process()
+
+
+def settle():
+    gc.collect()
+    time.sleep(0)
+    gc.collect()
+
+
+def memory():
+    return {"rss": PROCESS.memory_info().rss}
+
+
+def lifetime_peak_rss():
+    value = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    return value if sys.platform == "darwin" else value * 1024
+
+
+def time_operations(run, operations):
+    cpu_start = time.process_time_ns()
+    thread_start = time.thread_time_ns()
+    start = time.perf_counter_ns()
+    run()
+    elapsed = time.perf_counter_ns() - start
+    thread_cpu = time.thread_time_ns() - thread_start
+    cpu = time.process_time_ns() - cpu_start
+    return {
+        "elapsed_ns": elapsed,
+        "elapsed_time_per_op": elapsed / operations,
+        "process_cpu_time_per_op": cpu / operations,
+        "caller_thread_cpu_time_per_op": thread_cpu / operations,
+    }
+
+
+def allocation_totals(path):
+    import memray
+
+    allocators = {
+        memray.AllocatorType.PYMALLOC_MALLOC,
+        memray.AllocatorType.PYMALLOC_CALLOC,
+        memray.AllocatorType.PYMALLOC_REALLOC,
+    }
+    total_bytes = total_calls = 0
+    with memray.FileReader(path) as reader:
+        for record in reader.get_allocation_records():
+            if record.allocator in allocators:
+                total_bytes += record.size
+                total_calls += record.n_allocations
+    return {"allocated_bytes": total_bytes, "allocation_calls": total_calls}
+
+
+def sample_allocations(run):
+    import memray
+
+    with tempfile.TemporaryDirectory(prefix="posthog-allocations-") as directory:
+        path = Path(directory) / "allocations.bin"
+        with memray.Tracker(
+            path,
+            trace_python_allocators=True,
+            file_format=memray.FileFormat.ALL_ALLOCATIONS,
+        ):
+            run()
+        return allocation_totals(path)
+
+
+def classify_exit(*, timed_out=False, rss_limit_exceeded=False, stderr=""):
+    if timed_out:
+        return "timeout"
+    # A parent-enforced RSS ceiling is a measured limit violation, not proof of OS OOM.
+    if rss_limit_exceeded:
+        return "error"
+    if any(line.strip() == "MemoryError" for line in stderr.splitlines()):
+        return "oom"
+    return "error"
diff --git a/benchmarks/prepare.py b/benchmarks/prepare.py
new file mode 100644
index 000000000..c8405ce0b
--- /dev/null
+++ b/benchmarks/prepare.py
@@ -0,0 +1,81 @@
+"""Build an isolated, non-editable SDK installation with fixed benchmark tools."""
+
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+PACKAGES = "import importlib.metadata as m, json; print(json.dumps({d.metadata['Name'].lower().replace('_','-'): d.version for d in m.distributions()}))"
+
+
+def prepare(target, python_version, uv):
+    target = target.resolve()
+    environment = target / ".venv-benchmark"
+    env = {**os.environ, "UV_PROJECT_ENVIRONMENT": str(environment)}
+    subprocess.run(
+        [
+            uv,
+            "sync",
+            "--project",
+            str(target),
+            "--frozen",
+            "--no-dev",
+            "--no-editable",
+            "--compile-bytecode",
+            "--reinstall-package",
+            "posthog",
+            "--python",
+            python_version,
+        ],
+        env=env,
+        check=True,
+    )
+    python = environment / "bin/python"
+    # Inspect from outside the source tree; the worker must import the built wheel.
+    with tempfile.TemporaryDirectory(prefix="posthog-benchmark-prepare-") as cwd:
+        before = json.loads(
+            subprocess.check_output([python, "-I", "-c", PACKAGES], cwd=cwd)
+        )
+        subprocess.run(
+            [
+                uv,
+                "pip",
+                "install",
+                "--python",
+                str(python),
+                "--no-deps",
+                "--require-hashes",
+                "--compile-bytecode",
+                "-r",
+                str(Path(__file__).with_name("requirements.txt")),
+            ],
+            check=True,
+            cwd=cwd,
+        )
+        after = json.loads(
+            subprocess.check_output([python, "-I", "-c", PACKAGES], cwd=cwd)
+        )
+        changed = {
+            name: (version, after.get(name))
+            for name, version in before.items()
+            if after.get(name) != version
+        }
+        if changed:
+            raise RuntimeError(
+                f"Benchmark tooling changed locked SDK dependencies: {changed}"
+            )
+        subprocess.run(
+            [uv, "pip", "check", "--python", str(python)], check=True, cwd=cwd
+        )
+    return python
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("target", type=Path)
+    parser.add_argument("--python", default="3.12.12")
+    parser.add_argument("--uv", default="uv")
+    args = parser.parse_args()
+    print(prepare(args.target, args.python, args.uv))
diff --git a/benchmarks/requirements.in b/benchmarks/requirements.in
new file mode 100644
index 000000000..05ce099b7
--- /dev/null
+++ b/benchmarks/requirements.in
@@ -0,0 +1,3 @@
+# Benchmark-only instrumentation. Regenerate requirements.txt with uv pip compile.
+memray==1.20.0
+psutil==7.2.2
diff --git a/benchmarks/requirements.txt b/benchmarks/requirements.txt
new file mode 100644
index 000000000..0d770345f
--- /dev/null
+++ b/benchmarks/requirements.txt
@@ -0,0 +1,291 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile benchmarks/requirements.in --python-version 3.12 --universal --generate-hashes --exclude-newer 7 days --output-file benchmarks/requirements.txt
+jinja2==3.1.6 \
+    --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \
+    --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67
+    # via memray
+linkify-it-py==2.2.0 \
+    --hash=sha256:3adc40eb5af300b2605fcfdb968c24e1d780a90f1f2221af7c15e5111e94d443 \
+    --hash=sha256:907acd2d17ac1fbb9ddb62c8957ccbd6158cac602231a15c3b0cd1e215f03cee
+    # via markdown-it-py
+markdown-it-py==4.2.0 \
+    --hash=sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49 \
+    --hash=sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a
+    # via
+    #   mdit-py-plugins
+    #   rich
+    #   textual
+markupsafe==3.0.4 \
+    --hash=sha256:007e1ffd9bf65bb6ee96df7b258fc632a4868dd5566037986c64781f35a36e98 \
+    --hash=sha256:02fa4acbc6a3fc5c693c34d4dd8c1130b7fe99cc915181b0ddd6f72aeb296002 \
+    --hash=sha256:03470d1a8268e692ecf79ecd565593e59d44219377a7ead61f1f1b94c1f7ff6b \
+    --hash=sha256:04e7902ba80ee4bac1d50a549606527a1dcf0476cd81403db41099d3b60ec653 \
+    --hash=sha256:051417f74bcaaefa316276e0ff723f541616ca51043d070da00249d9bddd3e3c \
+    --hash=sha256:05295589e619b9bed252a86b532b8e27350abc372d18ba89b59375325e91ec1e \
+    --hash=sha256:06de8ef6331f6e822c28d577dc8bf43fe398800477c49498f38fc38b67ff33fc \
+    --hash=sha256:0764a13d34cae40db7bbf3a09b7e9b491bf4603e20b263a7a9d6b8e324975d0a \
+    --hash=sha256:077293e425f28ec737dbcad442a71752e28f8ae27cde3d68acd1fb212091cd92 \
+    --hash=sha256:0930db9bdc62d22944e10b066448bb65dc9abe9112880c7cab8da54db4284d5f \
+    --hash=sha256:0cee7cb0f9a1b6892ea482237d9403b3d1b4603aee057d0ff01f0fac2d019a97 \
+    --hash=sha256:0d9c47709875fdb321452056622e930c52afbc07a7d780762fbb8b4d91ce6fa4 \
+    --hash=sha256:11935df9bf455ed0c04eb87bcd720f02b1fe5e02128a9430f23aed6f93336fc7 \
+    --hash=sha256:12a606a492de952afcb43b59a14aaaaad120e708d3663dd0fdf2d738d427a691 \
+    --hash=sha256:14bd2d845d62ab678eaf81da89d7b621b51756c72346745c1a594c09d49207a2 \
+    --hash=sha256:15ba9e28640feef770374b116a6f019c21f52404aeabe516aa7f800587b98cfc \
+    --hash=sha256:18a801868a884f216e784d7d14db2a4077143ce7610440aee2ce8f734e7cfcde \
+    --hash=sha256:1c0df495a977d10460a94941799c72d5b5ab03d3858d949b55b5a66c8f371c99 \
+    --hash=sha256:1caa2fa5a6184fb233153b35f654e6687bd555476f6170f29d8ee9be1a8b0af9 \
+    --hash=sha256:1e1451fab512d1bcc3dc26988ec1edb0b82c2db909132872cd9356070a6b63df \
+    --hash=sha256:1f1f9477e174582b0a1b583d60b66e1f2cf5d3fe12cee985e4aedf44766600e5 \
+    --hash=sha256:2628d3a8cb648ecebb3c5d6b0a1052d400e4d8b7ac0fb786be8d285b50040d17 \
+    --hash=sha256:26e9867520db70d37f7fb421a7f0d8adb40171011fb84ce869afa1a83370dfa8 \
+    --hash=sha256:2a6ef68ae94aed8721934072b27a3b654ea2100b97e4ab864cf1489c90926fbc \
+    --hash=sha256:2b2b1e18af909b448bb3cf9e3433366f7a8726271fc214e8b10e0f62a78c724b \
+    --hash=sha256:2cb3dd71fc6be918ad4264346a8ed69485f9b7ed7bf35495d8e22807cd6b8bea \
+    --hash=sha256:2d1b7d9308288661f56672b1b157d75fc536714d3638487bbea17b6318a78248 \
+    --hash=sha256:2dad610540cb2e6272855c178f08ae9a1c7ac258a7fb71660553a5f104b42741 \
+    --hash=sha256:2e5a7cd7fdd14fcb1ae5d7d8bf23d24fbd1daefd1fbca2580132e1ea75f098b5 \
+    --hash=sha256:2e9ad7dd851bf45fab9f75cbff4cb493fee9979e8d8c7c9c3ee119022518edd6 \
+    --hash=sha256:340cbb1957ba99929cbf19a75626d36ba1ae21d1730b287d1cf7f824a20c4fc7 \
+    --hash=sha256:34bdde374c5932765d7dc685c4a1d191a3207852d67e8e0a9eb6ea85156181f1 \
+    --hash=sha256:353bd63081912ab8cfa6a0c7d185934cdf8426f04c618bba6bc4b394f2069b67 \
+    --hash=sha256:387d8cd30e69b3f0a72877b9ae717033396404e19095b17fe89753a981fda44f \
+    --hash=sha256:3882fb412298575bae3b9c46868251f15cc69307359f87bb1b382e53d6e5a2c9 \
+    --hash=sha256:38fc55594dab834470b6733dead2ee9e3f657fb0608c769dcafa0ba5ab52f45c \
+    --hash=sha256:396ec4e65cc889f69786b3b89478b471cee5a3bcf468b9d9bb03e1a30fb291fc \
+    --hash=sha256:39dbacefc411633db5b4378b066a9aca70a3d7e2922c9e578d825f844026eeba \
+    --hash=sha256:3a93d9616ddecfb393727a0041a562cf0b15a244e20f2bd25efc7949be4c4f17 \
+    --hash=sha256:3d23795802fc8bd72534836d64489bbf0f67c088959091bdb22e10735a5107bf \
+    --hash=sha256:434139499bb20b502ed3baa1f169e618f924a97e7a777fea1a49446d80106cf6 \
+    --hash=sha256:436e3ffc6310d3c41878c601db29098102fe5d8a467c49da4a4125254e0980f2 \
+    --hash=sha256:489505b03f692c3f376394e49194fa7a7f9e8558d6e293a7056a0032b0c38163 \
+    --hash=sha256:4a540e2d3192792fc84eced57bef37851ccb2b41f73291bb17408eea77bcd278 \
+    --hash=sha256:4a7cdc2a420ca01058182da4253329764d4bfa055564d1eced90e6ba1e8b1d3d \
+    --hash=sha256:4bced6e2a6dba6a28f7dd3c6ce14df1b2dd495923f16ea484cad03decd463b2b \
+    --hash=sha256:4cf3468d5ec187ffffcaca8e61929a37448f215dafc1386a12c750a72fe53634 \
+    --hash=sha256:4e2c4809c14559aa7ef426f27fb35afbb38104c349a903bf8f3600456764bb38 \
+    --hash=sha256:4ed644d75aa94a2baf7ec3a96eaa160ea58c742eb9d27c6506053c5c40fc84ed \
+    --hash=sha256:4f6e0852a0283b1b1fd776eeb7b766a5f440b3e2bd31ab51af3b400585f3965c \
+    --hash=sha256:5066b244f576f91afc8ee3ba029a89f99d39c79b1853fe9d39bea9f0afbec148 \
+    --hash=sha256:5086f9975abb1ab531ee6afca1761e4b59a19b446f3f6522ed776963228cfe5a \
+    --hash=sha256:50b5bedc9ed8a94fc8857a42ef4f84a81ea88f8d4f05dc8705fb23ee6d8dcca7 \
+    --hash=sha256:52704c5d36eb6dda8866493decd61111fff86244c9b1ad225ca01b9e91e5970f \
+    --hash=sha256:55ffd6ce583d97dc71dc92e930324c8c0d25aea7e3ade6ae54ef77cedb096811 \
+    --hash=sha256:569d65055d367e3dcdf30c3f41119467b73d9ee9faf332bdf40402644f5ac08e \
+    --hash=sha256:57f9947a7e57a081c1e3e0a2dd0d2dcf290a4531450e6f611e30084c222a7295 \
+    --hash=sha256:5989cb26b2e1efc6a42216a9f6b5ee495ce5ace2e5b352a9af489976b32d1ee2 \
+    --hash=sha256:5c22873ad1f0532ba40fa1727f3c0fc1bbbaab6d373d4cbe3f0dc74b2e2521c7 \
+    --hash=sha256:5e8b3d0b18fd623afa12ecb2ce8d8becef69f9b5440c6330c7972200e0bb84b0 \
+    --hash=sha256:61631e08084be9e21a8967ec3139c7616ed7c5e9368e05c86d1b39562c8a57b6 \
+    --hash=sha256:64511c54db4e4987aef4c41923235927428729e8174c5dba488429be70a998ed \
+    --hash=sha256:6669c1bf34080161ce49c589cc512ef24d4c704ac9d2b2d3667f519c60418378 \
+    --hash=sha256:672d207103e6b16ca098611b0f9efad6bc00afd47c03d6ef62186495ca677dc0 \
+    --hash=sha256:6768d67d1bce64270e0fdc2e69309d68b9b18ae56ddf6c711d168e9d051c2cac \
+    --hash=sha256:6a45c3d514f2436064db00d7fc8778d888f0236ebfed649b53d13a59e69ad51b \
+    --hash=sha256:6bd9e1788e15bfcf6a9082de42e30387e7b85d211ab21e57a939bb8cfaaf8d96 \
+    --hash=sha256:6d2a9efe686f9de00d0d1ea32a4a5a86d558a2277501bd78d964214eab625e59 \
+    --hash=sha256:6da83a088f8ef93b2d483a8232a4dbf4d69d3d8496b568a03c56becac43e1808 \
+    --hash=sha256:7018d4af1cd272e847aa5917983ab5e83e4f6579f9dbfecd4a79c0ca80b144c2 \
+    --hash=sha256:71f88e749ea29f67f21f3b36433c1dc54c7729ed2a6d9e2da2e0d9e0d7b224eb \
+    --hash=sha256:737c9c3981998eba27f11786f84fddcbabc74068b72a4a1f454ea02094b57b65 \
+    --hash=sha256:73e77980c7207854f00fc4e71fb1626868d5740ab4012623d55c7a99ad122a72 \
+    --hash=sha256:799c39bdf5e2f1292fedd3009f7b3c9e760f10b2420cb9638d56920840ff6db8 \
+    --hash=sha256:7a83aa6e4805df46fed18e989d3d16f86ef60cb50bbc8d9ce3a6be89165fbf6e \
+    --hash=sha256:7d3391b2188d18737cb2fa147028b1096236eaa7e156446c650a489fa2cadc91 \
+    --hash=sha256:7e1636da3d8dfc220b6dd10264db5f2b165e4888c4518594898fbe381049af8a \
+    --hash=sha256:805c8b84534fa10891890f0e4be39f3a99e94615d93e8836bf9fa1fdca2feeb2 \
+    --hash=sha256:811d02d5122171c1941357efd8f9bf4ffe907b7f0a1a4e729a880e4be3f46e3e \
+    --hash=sha256:8138eb83940ec7299024d92d4dee45f601b9e6c5ffde9d25f4e35e326203c707 \
+    --hash=sha256:83b3944fea42a8400edf92fd1770fb8d0d4f7de651353bd2d8525a92dba69a21 \
+    --hash=sha256:849dd2bb0e5e4ab2b71c7191726a4a8d5aa8a610daa584728cbee0b710ddc4ef \
+    --hash=sha256:8698d70a8081ee8c090dbb394768b5789a1da8b131b5499f89d071dd3cfaf6be \
+    --hash=sha256:8781a792a070cf2bd1b86d3aa943894115faaba6e88122a7bf32d62072742453 \
+    --hash=sha256:88d59b473bfb03259722600839af9bbd7fa13a2eb514beefeedb95997882f69a \
+    --hash=sha256:8909c2f1c6dd65e054ac4b573a91c8384d1492281e55d82d159d653f7a13adf6 \
+    --hash=sha256:8965520ac587c94a4ac48b729be3d8b8de00af39699b17585dfb599babe77977 \
+    --hash=sha256:8b5d563170ff8ba3181caa967c99a3c804d1dedb702c7cb93a6a7c32247da978 \
+    --hash=sha256:8e124f974786f831d6043728e38296969d3579db8896fe004682f5758e613581 \
+    --hash=sha256:8f0fac8b13d14bb06c68195f849371924ae53dd7b1c00fed24650f704383b692 \
+    --hash=sha256:9240187afb63d2f9ddc3e032c670356fe941f6e20662ea168a5dc3f1f317e1b3 \
+    --hash=sha256:925f929d6b59a8b3f8b8c6ac363cd0af7eecc81efb3071770b3c6717c450a369 \
+    --hash=sha256:9348cbb300d224fe3b89793262cb093504d4ae927004468463f745188a193e4a \
+    --hash=sha256:9388003072b95f2f1e3fd908604194d653ba21330d811961a78b7da1a77e9e36 \
+    --hash=sha256:9438a2648b2195980cb2dd8e53ed7b8df91319e2d0b70ae61a9e1d1bc8d3bec9 \
+    --hash=sha256:94e4c421742086aeee4c32a506eec8859d7634aad943f7e6aacf70f813478768 \
+    --hash=sha256:94f5407f7bc64fa6463906b896f9904beeeb7dd8dc116ee8e9056c8714ff9916 \
+    --hash=sha256:971a3bbb75d97ae4e2e8f7d4834236f86f85f0c85e04ab2e191db1123b04f80b \
+    --hash=sha256:9e227f3dbe6bde7491cf0a9965d00b88c6b1a4a95d11480ddf88bb96d397c19f \
+    --hash=sha256:9e25feb9e330b63edb0278a0acdf85e50d0cb0fbf49c3084abbe4e24ae195346 \
+    --hash=sha256:9f098115c247e11d138ab83a28fa0323c77015007ea2df73ba5fd714dfefd67c \
+    --hash=sha256:a18f38cafc329bac5e3c2b96c765b4c96d3d103421ed22ab7988c1e3fce27464 \
+    --hash=sha256:a4bbd2d87dd233b9fc5812160c3d0ffbe42edc22a26ce0469f58479ede633fe9 \
+    --hash=sha256:a5fcffb37e602b0b3c1638a97746b9b96125caa9bcf6fa41d337a9261de231ee \
+    --hash=sha256:a8e9f292fcda89b324f2f5c91d13f1424a153e40fc2756f38ee23b15835ff300 \
+    --hash=sha256:a9f54054101545a9a9cccefddf54316aa6e4491611fcbef9e91b3b6bebec04f6 \
+    --hash=sha256:aa2c838cc024642cc04c6854232f32b43e5e22833dd11119c1766c7873b8370d \
+    --hash=sha256:ac0c7c9f1609b0c4c114feb1d7a3409564c7fb77e360bed9e97e5d25dfeaf868 \
+    --hash=sha256:add96447a86d205ab616665d53b2950ee81083757f56e6ea833c8b2917646b46 \
+    --hash=sha256:ae9dcb8fbe244cb82f8a6458b455b927a03685e383d9bacf1ea5ce180b96dc97 \
+    --hash=sha256:b4a635a0487774f841cb1fb62e907e7195cc95bc761e053184b8acc3ceb20733 \
+    --hash=sha256:b4d12837e0203bbace818ff4a7461afdcd78bcd782351cea148139180d7bcffe \
+    --hash=sha256:b61687d0828e72bf5cda24a2690188f37170bd31c9359ac97e4e66569f120a16 \
+    --hash=sha256:b807e598953730f82e4eae3bd30f6a122cf6b31c398c6b504c0e04c13c170429 \
+    --hash=sha256:b8cd1f918b26fd7b1832ece557cc18f2d8747309ff8b3f0ef9d4250c5ad67a39 \
+    --hash=sha256:b91cc9d336957239ff200f30097e6fea2dc6d6fb3c81e853eaa09eac904fd894 \
+    --hash=sha256:bd3ce56ae2cbae3ba82b683bc425cd7e48d2ed8b10f3e818186b6f5646d9271c \
+    --hash=sha256:be6cb0c799abb0e2ba3e618e6d28ddddf7e485f6c2ce938dfa237daf3905072c \
+    --hash=sha256:befb4158af32106b9a93db8d6d1d1cbbd418c0d5aca0cabb7b1780abf0c89169 \
+    --hash=sha256:bf053da3c97a4bc5ecfbb218cdd2983febd91c617be8367d139882aa11e490aa \
+    --hash=sha256:c02e8f18bdedba082cef725942ac823b9b60656db07f7e265cb31618dfd00d77 \
+    --hash=sha256:c1bc67752d5f21013cfe430df4062441714eab79f65a6a05e01505957e9c35fe \
+    --hash=sha256:c61750fadcd119d0825bcb7d7d675dd264dcc89cc05292aab5be68ebdbb374ad \
+    --hash=sha256:c90d5b3d4e944e065a301d741b3c1d784f6bd1f503aa68b4967e32b2ba313d85 \
+    --hash=sha256:c9a7f43c0b202b334cc9184af09bb8f21d3a209e038efaf106936fb69e6b026e \
+    --hash=sha256:cb96e6e088d6cf71c1ea977510948320234824cf226e32f6f6e044f7a9c82b34 \
+    --hash=sha256:cf63c214fe879a65e69a386f915e36104fc84254ab141240f8854602d8e0be2a \
+    --hash=sha256:d1aca03ede943eb80ab3d63bb082c84b7aab85ea83bd0fd0c200260945fb49d9 \
+    --hash=sha256:d2e56fd3b00222722abfb3f5f0759ddbae4b90811b5ad4343c64030ad1bde70c \
+    --hash=sha256:d5f93ebbeb8032d47e349328ec8662d973d9b05a70b3c35df1f91fe419b84749 \
+    --hash=sha256:d882a373d8093c2941e01291b7ced96e9cbe4781da9a7751ca7e6c70385e5214 \
+    --hash=sha256:d920abdfa61279ba1a2ef9484aab07bf03331f8c08a10120fa332353d06e6932 \
+    --hash=sha256:da2af0d7aebfc2074080d72efa6ab8317c62481ef1f896f65d9999c1c01f4494 \
+    --hash=sha256:dd8ea6ebee7aedbf7c749fa80521d9ccf1ba473e0d1e14805caafbaad281c889 \
+    --hash=sha256:de8b364c423ef0a4bad9069657d617f9a5d2b2062457a89b1fa16ee199c399c1 \
+    --hash=sha256:df1ae86ff54725a01fa1a0510b914ca53a161b7050be74f6204e24aded5971d0 \
+    --hash=sha256:dff05cb7016dff1e9fd68f4122c127b65dfc59de5306cfb7ad92f956f230bee2 \
+    --hash=sha256:e1a622f13970d81f95d0c72f9dc090dce9085fccfa4c9f2174377ee32bd15786 \
+    --hash=sha256:e49fb0d1ce92cfa0cb198cc5b1b11cdf9d0638658e2a2db2687e39db7c87fc78 \
+    --hash=sha256:e5c802729725bd07e2bc3ab7b76dc7e0bbfc53129d8f1eb1c002c24cf774717e \
+    --hash=sha256:e841068dc0be4cb6dfb5c890eb88cbdcff2f4a332393c7ec94e8e618bd32c1a8 \
+    --hash=sha256:e916035e3e9930cbdfdd10abf48861340221857f45509565898e012263f7b289 \
+    --hash=sha256:eba154571c16e032112afac0dc2dfe9e63c2ceb7aedd07bb7eecf2ce26d4dd4c \
+    --hash=sha256:f03460ff076f70ab595bb45a0205ccea1971443575b6920c52e755dec2b3fbfe \
+    --hash=sha256:f0ec3b750b59375eab5b0fb2b9254810c00a3375be6d789899f1055a1d556237 \
+    --hash=sha256:f291bcf42ae98eb5107edb162c3c998b4a89648fd8e99ed4cbd12705292788cd \
+    --hash=sha256:f61efe1d2fe0de16158a5fe1d1cf3c14bdb6aecd54d8938fd26512c525c1f624 \
+    --hash=sha256:f68edfc67aabac33708941f26f22a7b8e9f81429bc0cf249fcf7d66b23af8d19 \
+    --hash=sha256:fa95848c929b6a75f6848d3c9793e59db365ee436776e57db835cdbfa79ba977 \
+    --hash=sha256:fd9f8797427910198f95bced71ddfed61130d7e349213bfb8466c9c99e2c46a8 \
+    --hash=sha256:fdb4ca07ab75ffadab4a8b135ad59cdbb3156b99310f3d565370da74a15d6bd3
+    # via jinja2
+mdit-py-plugins==0.6.1 \
+    --hash=sha256:214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d \
+    --hash=sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0
+    # via textual
+mdurl==0.1.2 \
+    --hash=sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8 \
+    --hash=sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba
+    # via markdown-it-py
+memray==1.20.0 \
+    --hash=sha256:0601310f1be3fd5012d888fa73354c204d7eb85cd42a89bd91160d3b8a1ada9e \
+    --hash=sha256:08b4d1e17219caabc2a01aa17e8e602b9db67a6aad3ba88b134dfc22bace420d \
+    --hash=sha256:0c18705b70d20161616d3fc9d0b0c7796211b3ab16499dfb29c8f3ab7ece46c2 \
+    --hash=sha256:0f2b2e3640bcff1d2e20f431fb93d17ac03236b28d53087d5e16c87139b4865e \
+    --hash=sha256:1a4735275b385d6a962f4123facfe98ab306b39b084ba10ecda4d1df930d1990 \
+    --hash=sha256:25e4a802488d54030c30a6bdb969fd79f701228db35e6a834eac75259c69018b \
+    --hash=sha256:27dc015d1bfb9e43dc0030b412ba435ccff89cd5b7b28d7da9c8e630e7cfe3ec \
+    --hash=sha256:2a6d63a3df7eb96809b82cbd9445033ec1d51574be0f9b3eddf4d64632af7162 \
+    --hash=sha256:2f51218744259983ad0ca66366ca2ff80158513132ca9bd835b1874a453199dd \
+    --hash=sha256:3270aad45dfa0bc7d32bb86b352aefabee765a8658aace8fb9dc8112a07f2e3c \
+    --hash=sha256:359824cc26c9a208e83ab058850e9bf16592d7928307e8c2dc6c7b55e6b6cfa6 \
+    --hash=sha256:37bc107afee942f162d30160dfd7f28c2b989251c574570f2f920f5bbbb323e4 \
+    --hash=sha256:3c3aec7a4d0b0d0eb55d72e815a492ff060a3a46b014f6ae216ae68a006ea304 \
+    --hash=sha256:3d40d606d0f1d248bb5a00701de84d8faab8ec5b6b383305a36f14c1849a7125 \
+    --hash=sha256:420bc47528fedf1a92832290c7a7b8a940c2e30bd9337a85811da18a27e07220 \
+    --hash=sha256:4d55e9627b6d6a868aa45995a965f3396c56ac7df5bc567b5293068412049557 \
+    --hash=sha256:53231e49d55b10ac10ac8739a2592230f0794320892756f957e0026f99f38618 \
+    --hash=sha256:546a60027fc9c8a5fbeea62dce45e830d78769a45192098469ee39b2d75c97fc \
+    --hash=sha256:5588174a24ac150100faa7ee60b535b0f09eae82bf672133443425a00704b769 \
+    --hash=sha256:57981abd8c526d4375c7f640a9d27d5e319b888e79b51688a8fae2f947fe8294 \
+    --hash=sha256:59e44042f2495698f6a17fe0a831051ea515242e567f08457ee8546283372993 \
+    --hash=sha256:5dd0d4220b607d85aaf6a7275d032915ad43a170b6ae9c73943952d39c224b9b \
+    --hash=sha256:5e76806fa8e0fdf0c83285afac2b0a661a48f9ce03d746638fe2e43433a4e67c \
+    --hash=sha256:5edcfdd7071628dbcfe5334875cb1d615e26f39a613a2cc2767c193a544b91de \
+    --hash=sha256:60f3bf8762adc15a2214f44ad631cddb9e4fa4f4a0dda6aa0ccac6ea71239283 \
+    --hash=sha256:610643cfa186f7958a476e5589f6e8a1b0b7b3008ab10250a0f02575a692ef1d \
+    --hash=sha256:68dca0caa0b1d1b8474ee54efb98eeb33f548d28bb246113caac45125da7b9c3 \
+    --hash=sha256:70010acd3d07dbf41aaca0787de3c81c5d8e22e07a6c0fdf04d66c4a376c0193 \
+    --hash=sha256:734a082db18947f8afa609b2b4daca20a8b45100a3e6b6c0e4321d59ed781288 \
+    --hash=sha256:7bcd5094cbb9bd1d11a5dfcc523daaa99f743e645a8b0b0805beaa2bbddbf356 \
+    --hash=sha256:7e106a6dfd3823194a5ecd0b147ea7cffae900e422402cfac9ff4b2c774b4695 \
+    --hash=sha256:8001648aeabd15235337b907a61bc8f26483633057dc987199f50a8977a72d7e \
+    --hash=sha256:83cfa504ed4e1061b85af4b3c40228616a852851ebf5968ff1c3d85e363f8d24 \
+    --hash=sha256:83eeeadb3a14ecd8180fe53fe7f0287a84d4146f7fdca986291a5fc1f4eeee97 \
+    --hash=sha256:90fc0ebfc6a264fe3b77d5c263678eaf4a47a0f4288e1b6a04ae3439743cd4be \
+    --hash=sha256:97539fd71c565c55e208df9ea28ac158cd156b8c33564853685688595c5a991b \
+    --hash=sha256:996db26e0451301ed935d357854bf84ff1e41bc43580901bf37528a09a8dac3c \
+    --hash=sha256:9b21b9cb85699f9b8df664f6c1633e2a9ce9072e8a7ca15700075e4111b001ed \
+    --hash=sha256:9b33c58a7bb6b04d9767249924c0d342a9c33ec3526aeb52f95a0185b0f30aca \
+    --hash=sha256:9c80ecc9259acd888647a385a2f429f453f7ba5c0b1af363babd1ad8a1210da6 \
+    --hash=sha256:9d0c12433fde039a594b6bc254758c236db5532a4ee2ed758b9ec73f8fc78f62 \
+    --hash=sha256:a5fc5251b02d99a98eb5874cabfcb74b492ab28e1d5c8b55d481ba0d5e273bf0 \
+    --hash=sha256:a6b79c356f7caeed51cbd25dee85485b6210803199f769da8bc3d061bd0e0ada \
+    --hash=sha256:a9e3db4952fe56d74036a4e1bcafd6c8c257390021f752d932394fbf3b389a67 \
+    --hash=sha256:ab77856a592b04586ffb4a87e26d4de440ee3aba6facbaeabdb20855950fdebc \
+    --hash=sha256:ac9a5dd9bef7f44331d98174625167bf0a8f61785ed05440d99f581c93790acf \
+    --hash=sha256:b40bf09977f84afe815cca1f34f8a29040a9e757b55467d513ecb9262e6bd809 \
+    --hash=sha256:b41289728ec76b48e83a1af9e1e45e997c4e4b692bfbdeb07cfd814bccb24c40 \
+    --hash=sha256:b71fe846cbabce7f33017ac94ba2f157b39e22dbc4f723aad0407dd38520f855 \
+    --hash=sha256:b9ec82a31783a6e468135a6f8a7a996fbc31530a5b725faffb5a8be7e2431a2b \
+    --hash=sha256:bab7e524faeb76c607d364ed341592cadc1e39beb634da5cf58f77f9a0f68001 \
+    --hash=sha256:c19934e6b713dbbf35f15d3c84f289e048be613e85039913a500393f10272b9f \
+    --hash=sha256:c8c6ee6c3df06abf2d4230d0f2c0440e91e0c8fd51c1fe9b32599485254d1f56 \
+    --hash=sha256:cdf08e64a9bcb598ae76ca467273b580b4658de49b73bd78dd8345a736d78816 \
+    --hash=sha256:ce1f1d900948d57d7db5b5d8d81f4ebfcb798eff674493503ce5bfaafcea84dc \
+    --hash=sha256:d1503ac18928d2493662af95935b9ccaadbf9f2579d86f6757304c23291a077b \
+    --hash=sha256:d2f3f681ce8acd713a7216d6c362387e70122527e741685e82f85cfdf6aedf0b \
+    --hash=sha256:d92692fb5266aca4322e2001e18810207b170dfc7ce2e8f0570c7ee181574063 \
+    --hash=sha256:e073ef4685c7f7c2e9c5dabcff8ff46cae66daf6aeaea4d017239b2940b4ca82 \
+    --hash=sha256:e430f8f8533d17bbf45ad0e0c2f16c0e0b767729234771b06745670b61ea5f26 \
+    --hash=sha256:e64121d1b3ca248e0af39df09593bd2b04779ff8ee5261ea9b46ae5e47bc1c7e \
+    --hash=sha256:f5d6980770a2d5d1a4f3e8d04d6f92309119671c1f830959a8bea868fab0b01f \
+    --hash=sha256:f6653ac2fbd49e66e2883575fa8c5dde127f4699205415d1170a8cf7d1db1c86 \
+    --hash=sha256:ffd3c7c53419465922be92654c17ebff577708fa1f74168dbef9eb5efa6bcb02
+    # via -r benchmarks/requirements.in
+platformdirs==4.13.5 \
+    --hash=sha256:05831adf87d392760f4b5c3a0a95579ab5a10b18b9b9bd43680dcb47544788a0 \
+    --hash=sha256:53d3ec4280b815c1e0b02edad7f9ee8fda1ba9c0865dd9c2e6e63849ce82fc1e
+    # via textual
+psutil==7.2.2 \
+    --hash=sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372 \
+    --hash=sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9 \
+    --hash=sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841 \
+    --hash=sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63 \
+    --hash=sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979 \
+    --hash=sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a \
+    --hash=sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b \
+    --hash=sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9 \
+    --hash=sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee \
+    --hash=sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312 \
+    --hash=sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b \
+    --hash=sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9 \
+    --hash=sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e \
+    --hash=sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc \
+    --hash=sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1 \
+    --hash=sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf \
+    --hash=sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea \
+    --hash=sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988 \
+    --hash=sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486 \
+    --hash=sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00 \
+    --hash=sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8
+    # via -r benchmarks/requirements.in
+pygments==2.21.0 \
+    --hash=sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9 \
+    --hash=sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c
+    # via
+    #   rich
+    #   textual
+rich==15.0.0 \
+    --hash=sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb \
+    --hash=sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36
+    # via
+    #   memray
+    #   textual
+textual==8.2.8 \
+    --hash=sha256:267375fd402dc8d981457212efa71f0e3365fd17bba144ba9bb3ed7563cb374a \
+    --hash=sha256:3f106a9fbc73e39dd266c9712432087de78a6d644084c7c241d6a25c3169115b
+    # via memray
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via textual
diff --git a/benchmarks/run.py b/benchmarks/run.py
new file mode 100644
index 000000000..d7fb14f91
--- /dev/null
+++ b/benchmarks/run.py
@@ -0,0 +1,395 @@
+"""Run the head-side suite against two independently installed SDK revisions."""
+
+import argparse
+import json
+import math
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import uuid
+from pathlib import Path
+
+import psutil
+from fixtures import USERS, definitions, digest, workloads
+from identity import source_digest
+from measurement import classify_exit
+from server import BenchmarkServer
+
+HERE = Path(__file__).resolve().parent
+WORKER = HERE / "worker.py"
+TIMEOUT = 120
+MAX_WORKER_TIMEOUTS = 2
+RSS_LIMIT = 512 * 1024 * 1024
+
+
+def worker_env():
+    env = {
+        key: value for key, value in os.environ.items() if not key.startswith("PYTHON")
+    }
+    env.update(
+        PYTHONHASHSEED="0",
+        PYTHONNOUSERSITE="1",
+        PYTHONDONTWRITEBYTECODE="1",
+        POSTHOG_CAPTURE_MODE="v0",
+    )
+    return env
+
+
+def run_worker(python, spec, measurement_pass, timeout=TIMEOUT, rss_limit=RSS_LIMIT):
+    with (
+        tempfile.TemporaryDirectory(prefix="posthog-benchmark-worker-") as directory,
+        BenchmarkServer(spec) as server,
+    ):
+        output = Path(directory) / "result.json"
+        command = [
+            str(python),
+            "-B",
+            str(WORKER),
+            json.dumps({**spec, "pass": measurement_pass}),
+            server.url,
+            str(output),
+        ]
+        with subprocess.Popen(
+            command,
+            cwd=directory,
+            env={**worker_env(), "TMPDIR": directory},
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        ) as process:
+            logs = {"stdout": bytearray(), "stderr": bytearray()}
+
+            def read_log(stream, target):
+                while chunk := stream.read(4096):
+                    target.extend(chunk)
+                    del target[:-65536]
+
+            readers = [
+                threading.Thread(
+                    target=read_log,
+                    args=(getattr(process, name), logs[name]),
+                    daemon=True,
+                )
+                for name in logs
+            ]
+            for reader in readers:
+                reader.start()
+            observed = psutil.Process(process.pid)
+            start = time.monotonic()
+            timed_out = limit_exceeded = False
+            while process.poll() is None:
+                try:
+                    limit_exceeded = observed.memory_info().rss > rss_limit
+                except psutil.NoSuchProcess:
+                    pass
+                timed_out = time.monotonic() - start > timeout
+                if timed_out or limit_exceeded:
+                    process.kill()
+                    break
+                time.sleep(0.02)
+            process.wait()
+            for reader in readers:
+                reader.join()
+            diagnostic = {
+                name: data.decode("utf-8", errors="replace")
+                for name, data in logs.items()
+            }
+            if (
+                process.returncode == 0
+                and output.exists()
+                and not timed_out
+                and not limit_exceeded
+            ):
+                if output.stat().st_size > 2 * 1024 * 1024:
+                    raise ValueError("Worker result exceeds size limit")
+                return {"status": "ok", **json.loads(output.read_text()), **diagnostic}
+            return {
+                "status": classify_exit(
+                    timed_out=timed_out,
+                    rss_limit_exceeded=limit_exceeded,
+                    stderr=diagnostic["stderr"],
+                ),
+                "code": process.returncode,
+                "pass": measurement_pass,
+                "rss_limit_exceeded": limit_exceeded,
+                "error": "Worker exceeded RSS limit"
+                if limit_exceeded
+                else "Worker did not complete",
+                **diagnostic,
+            }
+
+
+def git(directory, *args):
+    return subprocess.check_output(
+        ["git", "-C", str(directory), *args], text=True
+    ).strip()
+
+
+def document_for(directory, role, pair_id, suite):
+    python = directory / ".venv-benchmark/bin/python"
+    with tempfile.TemporaryDirectory(prefix="posthog-benchmark-identity-") as cwd:
+        execution = json.loads(
+            subprocess.check_output(
+                [python, "-B", WORKER, "--describe"],
+                cwd=cwd,
+                env=worker_env(),
+                text=True,
+            )
+        )
+    execution.update(
+        {
+            "pair_id": pair_id,
+            "runtime_flags": ["-B"],
+            "python_hash_seed": 0,
+            "bytecode_policy": "uv precompiles both environments; workers do not write bytecode",
+            "runner_class": "github-hosted-or-self-hosted"
+            if os.getenv("RUNNER_NAME")
+            else "local",
+            "runner_image": os.getenv("ImageVersion"),
+            "dependency_lock_digest": digest((directory / "uv.lock").read_bytes()),
+            "resource_limits": {
+                "process_rss_limit_bytes": RSS_LIMIT,
+                "worker_timeout_ms": TIMEOUT * 1000,
+                "max_worker_timeouts": MAX_WORKER_TIMEOUTS,
+            },
+        }
+    )
+    return {
+        "schema_version": 1,
+        "sdk": "posthog-python",
+        "revision": {
+            "role": role,
+            "commit": git(directory, "rev-parse", "HEAD"),
+            "dirty": bool(
+                git(
+                    directory,
+                    "status",
+                    "--porcelain",
+                    "--",
+                    ".",
+                    ":(exclude).venv-benchmark",
+                )
+            ),
+        },
+        "suite": suite,
+        "execution": execution,
+        "benchmarks": [],
+    }
+
+
+def append_sample(benchmark, raw, repetition):
+    benchmark["runs"].append({"repetition": repetition, **raw})
+    if raw["status"] != "ok":
+        benchmark["status"] = raw["status"]
+        return
+
+    def add(name, unit, method, value):
+        if not math.isfinite(value) or value < 0:
+            raise ValueError(f"Invalid {name}: {value}")
+        metric = next((m for m in benchmark["metrics"] if m["id"] == name), None)
+        if metric is None:
+            metric = {
+                "id": name,
+                "unit": unit,
+                "method": method,
+                "quality": "measured",
+                "direction": "lower",
+                "status": "ok",
+                "samples": [],
+            }
+            benchmark["metrics"].append(metric)
+        metric["samples"].append(
+            {
+                "repetition": repetition,
+                "value": value,
+                "operations": raw["operations"],
+                **({"elapsed_ns": raw["elapsed_ns"]} if "elapsed_ns" in raw else {}),
+            }
+        )
+
+    def unavailable(name, unit, reason):
+        if not any(m["id"] == name for m in benchmark["metrics"]):
+            benchmark["metrics"].append(
+                {"id": name, "unit": unit, "status": "unsupported", "reason": reason}
+            )
+
+    if raw["pass"] == "timing":
+        add(
+            "elapsed_time_per_op",
+            "ns/op",
+            "time.perf_counter_ns",
+            raw["elapsed_time_per_op"],
+        )
+        if "process_cpu_time_per_op" in raw:
+            add(
+                "process_cpu_time_per_op",
+                "ns/op",
+                "time.process_time_ns",
+                raw["process_cpu_time_per_op"],
+            )
+        else:
+            add(
+                "caller_thread_cpu_time_per_op",
+                "ns/op",
+                "time.thread_time_ns",
+                raw["caller_thread_cpu_time_per_op"],
+            )
+            for name, unit in (
+                ("allocated_bytes_per_op", "bytes/op"),
+                ("allocations_per_op", "count/op"),
+            ):
+                unavailable(
+                    name,
+                    unit,
+                    "Background preparation has no public completion boundary before flush; see capture.drain for full-pipeline allocations.",
+                )
+    elif raw["pass"] == "allocation":
+        add(
+            "allocated_bytes_per_op",
+            "bytes/op",
+            "memray.python_allocator_requests",
+            raw["allocated_bytes"] / raw["operations"],
+        )
+        add(
+            "allocations_per_op",
+            "count/op",
+            "memray.python_allocator_requests",
+            raw["allocation_calls"] / raw["operations"],
+        )
+    elif raw["pass"] == "memory":
+        add(
+            "idle_process_rss",
+            "bytes",
+            "psutil.Process.memory_info.rss",
+            raw["before"]["rss"],
+        )
+        add(
+            "observed_workload_peak_rss",
+            "bytes",
+            "psutil.Process.memory_info.rss.operation_checkpoints",
+            raw["observed_peak_rss"],
+        )
+        add(
+            "process_lifetime_peak_rss",
+            "bytes",
+            "resource.getrusage.ru_maxrss",
+            raw["process_lifetime_peak_rss"],
+        )
+        add(
+            "post_settling_process_rss",
+            "bytes",
+            "psutil.Process.memory_info.rss",
+            raw["after_settling"]["rss"],
+        )
+        unavailable(
+            "post_settling_heap_used",
+            "bytes",
+            "CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.",
+        )
+
+
+def main(args=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--base", type=Path, required=True)
+    parser.add_argument("--head", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--repetitions", type=int, default=6, choices=range(1, 31))
+    parser.add_argument("--smoke", action="store_true")
+    parser.add_argument("--filter", default="")
+    options = parser.parse_args(args)
+    specs = [
+        spec
+        for spec in workloads(options.smoke)
+        if spec["id"].startswith(options.filter)
+    ]
+    if not specs:
+        parser.error("No matching workloads")
+    pair_id = str(uuid.uuid4())
+    suite = {
+        "id": "python-sdk-performance",
+        "version": 1,
+        "source_commit": git(HERE, "rev-parse", "HEAD"),
+        "source_digest": source_digest(HERE),
+        "profile": "smoke" if options.smoke else "full",
+        "repetitions": options.repetitions,
+        "allocation_tracking": {
+            "trace_python_allocators": True,
+            "file_format": "ALL_ALLOCATIONS",
+            "scope": "PYMALLOC_MALLOC/CALLOC/REALLOC requests; all worker threads",
+        },
+        "transport": "loopback HTTP receiver in coordinator process; uncompressed v0",
+        "settling": "two gc.collect calls separated by sleep(0)",
+        "memory_sampling": "operation checkpoints; lifetime high-water mark includes setup and warmup",
+        "capture": {
+            "flush_at": 100000,
+            "flush_interval_seconds": 3600,
+            "consumer_threads": 1,
+            "drain_every": 100,
+        },
+        "flag_poll_interval_seconds": 3600,
+    }
+    directories = {"base": options.base.resolve(), "head": options.head.resolve()}
+    documents = {
+        role: document_for(directory, role, pair_id, suite)
+        for role, directory in directories.items()
+    }
+    for key in ("runtime_version", "measurement_tools", "os", "arch"):
+        if documents["base"]["execution"][key] != documents["head"]["execution"][key]:
+            raise ValueError(f"Base/head {key} differ")
+    options.output.mkdir(parents=True, exist_ok=True)
+
+    def save():
+        for role, document in documents.items():
+            temporary = options.output / f"{role}.json.tmp"
+            temporary.write_text(json.dumps(document, indent=2, allow_nan=False) + "\n")
+            temporary.replace(options.output / f"{role}.json")
+
+    failures = 0
+    timeouts = 0
+    for spec in specs:
+        records = {}
+        for role in directories:
+            records[role] = {
+                "id": spec["id"],
+                "parameters": spec,
+                "fixture_digest": digest(
+                    {
+                        "spec": spec,
+                        "definitions": definitions(spec["flag_count"])
+                        if "flag_count" in spec
+                        else None,
+                        "users": USERS,
+                    }
+                ),
+                "status": "ok",
+                "metrics": [],
+                "runs": [],
+            }
+            documents[role]["benchmarks"].append(records[role])
+        for repetition in range(options.repetitions):
+            for measurement_pass in spec["passes"]:
+                for role in ["head", "base"] if repetition % 2 else ["base", "head"]:
+                    raw = run_worker(
+                        directories[role] / ".venv-benchmark/bin/python",
+                        spec,
+                        measurement_pass,
+                    )
+                    append_sample(records[role], raw, repetition)
+                    failures += raw["status"] != "ok"
+                    timeouts += raw["status"] == "timeout"
+                    print(
+                        f"{spec['id']} {measurement_pass} {repetition + 1}/{options.repetitions} {role}: {raw['status']}",
+                        file=sys.stderr,
+                    )
+                    save()
+                if timeouts >= MAX_WORKER_TIMEOUTS:
+                    return 1
+            if any(record["status"] != "ok" for record in records.values()):
+                break
+    return int(failures > 0)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/benchmarks/server.py b/benchmarks/server.py
new file mode 100644
index 000000000..b513791bf
--- /dev/null
+++ b/benchmarks/server.py
@@ -0,0 +1,119 @@
+"""Bounded loopback receiver owned by the coordinator, never the measured worker.
+
+The SDK has no public transport injection option. HTTP preserves its normal
+loading, serialization, background-consumer and flush paths.
+"""
+
+import json
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+from urllib.parse import urlsplit
+
+from fixtures import USERS, definitions
+
+
+class BenchmarkServer:
+    def __init__(self, spec, batch_delay=0):
+        self.spec = spec
+        self.lock = threading.Lock()
+        self.payload = "x" * spec.get("payload_bytes", 0)
+        self.body = json.dumps(definitions(spec.get("flag_count", 0))).encode()
+        self.state: dict[str, Any] = {
+            "definitions": 0,
+            "delivered": 0,
+            "requests": 0,
+            "invalid_events": 0,
+            "delivered_by_user": {user["distinct_id"]: 0 for user in USERS},
+            "unexpected": [],
+        }
+        owner = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def log_message(self, *args):
+                pass
+
+            def reply(self, status, body):
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def do_GET(self):
+                with owner.lock:
+                    path = urlsplit(self.path).path.rstrip("/")
+                    if path == "/flags/definitions":
+                        owner.state["definitions"] += 1
+                        self.reply(200, owner.body)
+                    elif path == "/__benchmark/state":
+                        self.reply(200, json.dumps(owner.state).encode())
+                    else:
+                        self.unexpected(path)
+
+            def unexpected(self, path):
+                if len(owner.state["unexpected"]) < 20:
+                    owner.state["unexpected"].append(path)
+                self.reply(404, b'{"error":"unexpected benchmark request"}')
+
+            def do_POST(self):
+                with owner.lock:
+                    path = urlsplit(self.path).path.rstrip("/")
+                    try:
+                        size = int(self.headers.get("Content-Length", "0"))
+                        if not 0 < size <= 20 * 1024 * 1024:
+                            raise ValueError("Invalid body length")
+                        body = json.loads(self.rfile.read(size))
+                        if path == "/__benchmark/definitions":
+                            generation = body["generation"]
+                            if (
+                                not isinstance(generation, int)
+                                or not 0 <= generation <= 1000
+                            ):
+                                raise ValueError("Invalid generation")
+                            owner.body = json.dumps(
+                                definitions(spec["flag_count"], generation)
+                            ).encode()
+                            self.reply(200, b"{}")
+                        elif path == "/batch":
+                            if batch_delay:
+                                time.sleep(batch_delay)
+                            batch = body["batch"]
+                            if not isinstance(batch, list):
+                                raise ValueError("Invalid batch")
+                            owner.state["requests"] += 1
+                            owner.state["delivered"] += len(batch)
+                            for event in batch:
+                                properties = event.get("properties", {})
+                                user = event.get("distinct_id")
+                                if (
+                                    event.get("event") != "benchmark"
+                                    or user not in owner.state["delivered_by_user"]
+                                    or properties.get("payload") != owner.payload
+                                    or properties.get("plan") != "pro"
+                                ):
+                                    owner.state["invalid_events"] += 1
+                                else:
+                                    owner.state["delivered_by_user"][user] += 1
+                            self.reply(200, b'{"status":1}')
+                        else:
+                            self.unexpected(path)
+                    except (ValueError, KeyError, TypeError, AttributeError):
+                        owner.state["invalid_events"] += 1
+                        self.reply(400, b'{"error":"invalid benchmark body"}')
+
+        self.http = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        self.thread = threading.Thread(
+            target=self.http.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True
+        )
+        self.url = f"http://127.0.0.1:{self.http.server_port}"
+
+    def __enter__(self):
+        self.thread.start()
+        return self
+
+    def __exit__(self, *_):
+        self.http.shutdown()
+        self.http.server_close()
+        self.thread.join()
diff --git a/benchmarks/test_benchmarks.py b/benchmarks/test_benchmarks.py
new file mode 100644
index 000000000..b5dd19983
--- /dev/null
+++ b/benchmarks/test_benchmarks.py
@@ -0,0 +1,387 @@
+import gc
+import json
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from typing import Any
+from unittest.mock import patch
+from urllib.error import HTTPError
+
+import memray
+from fixtures import USERS, definitions, digest, expected_flags, workloads
+from identity import environment, source_digest
+from measurement import (
+    allocation_totals,
+    classify_exit,
+    memory,
+    sample_allocations,
+    settle,
+    time_operations,
+)
+from prepare import prepare
+from run import append_sample, main, run_worker
+from server import BenchmarkServer
+from workload import Workload, control
+
+from posthog import Posthog
+
+ROOT = Path(__file__).resolve().parents[1]
+PYTHON = ROOT / ".venv-benchmark/bin/python"
+
+
+class BenchmarksTest(unittest.TestCase):
+    def test_deterministic_and_changing_fixtures(self):
+        self.assertEqual(digest(definitions(1000)), digest(definitions(1000)))
+        self.assertNotEqual(digest(definitions(1000)), digest(definitions(1000, 1)))
+        self.assertTrue(expected_flags(10, USERS[0])["boolean-0"])
+        self.assertFalse(expected_flags(10, USERS[0], 1)["boolean-0"])
+        self.assertFalse(expected_flags(10, USERS[0], 1)["cohort-5"])
+
+    def test_public_entry_fixtures_and_lifecycle(self):
+        for spec in workloads(smoke=True):
+            with self.subTest(workload=spec["id"]), BenchmarkServer(spec) as server:
+                workload = Workload(spec, server.url)
+                try:
+                    workload.run()
+                    counts = workload.verify()
+                    self.assertEqual(counts["unexpected"], [])
+                    if spec["mode"] == "refresh":
+                        self.assertEqual(counts["definitions"], spec["operations"] + 1)
+                    if spec["mode"] in ("capture", "drain"):
+                        self.assertEqual(counts["delivered"], spec["operations"])
+                finally:
+                    workload.close()
+                self.assertFalse(
+                    any(thread.is_alive() for thread in workload.client.consumers)
+                )
+                if workload.client.poller:
+                    self.assertFalse(workload.client.poller.is_alive())
+
+    def test_remote_fallback_is_not_a_successful_fake_evaluation(self):
+        with BenchmarkServer(workloads(True)[0]) as server:
+            with self.assertRaises(HTTPError):
+                control(server.url, "/flags/?v=2", {})
+            self.assertEqual(
+                control(server.url, "/__benchmark/state")["unexpected"], ["/flags"]
+            )
+
+    def test_capture_checks_payload_and_identity_distribution(self):
+        for mutation in ("payload", "identity"):
+
+            class Corrupted(Posthog):
+                def capture(self, event, _mutation=mutation, **kwargs):
+                    if _mutation == "payload":
+                        kwargs["properties"] = {**kwargs["properties"], "payload": ""}
+                    else:
+                        kwargs["distinct_id"] = USERS[0]["distinct_id"]
+                    return super().capture(event, **kwargs)
+
+            spec = next(s for s in workloads(True) if s["id"] == "capture.enqueue.4096")
+            with self.subTest(mutation=mutation), BenchmarkServer(spec) as server:
+                workload = Workload(spec, server.url, client_class=Corrupted)
+                try:
+                    workload.run()
+                    with self.assertRaises(AssertionError):
+                        workload.verify()
+                    self.assertEqual(workload.state()["delivered"], spec["operations"])
+                finally:
+                    workload.close()
+
+    def test_delayed_draining_finishes_inside_the_measurement(self):
+        calls = []
+
+        class ShortDeadline(Posthog):
+            def flush(self, timeout_seconds=10):
+                calls.append(timeout_seconds)
+                # Make finite-deadline misuse observable without a five-second test.
+                return super().flush(
+                    timeout_seconds=None if timeout_seconds is None else 0.001
+                )
+
+        spec = {
+            **next(s for s in workloads(True) if s["id"] == "capture.drain.32"),
+            "operations": 100,
+        }
+        with BenchmarkServer(spec, batch_delay=0.05) as server:
+            workload = Workload(spec, server.url, client_class=ShortDeadline)
+            try:
+                measured = time_operations(workload.run, spec["operations"])
+                self.assertGreaterEqual(measured["elapsed_ns"], 50_000_000)
+                self.assertEqual(calls, [None])
+                self.assertEqual(workload.verify()["delivered"], 100)
+                self.assertEqual(
+                    calls,
+                    [None],
+                    "Verification must not rescue an unfinished measured drain",
+                )
+            finally:
+                workload.close()
+
+    def test_preparation_forces_a_source_rebuild_and_preserves_runtime_versions(self):
+        with (
+            tempfile.TemporaryDirectory() as directory,
+            patch("prepare.subprocess.run") as run,
+            patch(
+                "prepare.subprocess.check_output",
+                return_value=b'{"posthog":"1.0","requests":"2.0"}',
+            ),
+        ):
+            prepare(Path(directory), "3.12.12", "uv")
+            command = run.call_args_list[0].args[0]
+            self.assertEqual(
+                command[command.index("--reinstall-package") + 1], "posthog"
+            )
+            self.assertIn("--frozen", command)
+            self.assertIn("--no-editable", command)
+            self.assertIn("--compile-bytecode", command)
+            self.assertIn("--compile-bytecode", run.call_args_list[1].args[0])
+        with (
+            tempfile.TemporaryDirectory() as directory,
+            patch("prepare.subprocess.run"),
+            patch(
+                "prepare.subprocess.check_output",
+                side_effect=[b'{"requests":"2.0"}', b'{"requests":"3.0"}'],
+            ),
+            self.assertRaisesRegex(RuntimeError, "changed locked SDK dependencies"),
+        ):
+            prepare(Path(directory), "3.12.12", "uv")
+
+    def test_allocation_churn_includes_freed_small_python_allocations(self):
+        def churn():
+            for _ in range(20000):
+                value = bytearray(200)
+                del value
+            gc.collect()
+
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "default.bin"
+            with memray.Tracker(path):
+                churn()
+            self.assertEqual(allocation_totals(path)["allocation_calls"], 0)
+        measured = sample_allocations(churn)
+        # Includes allocator requests even when objects have already been released.
+        self.assertGreater(measured["allocated_bytes"], 20000 * 200)
+        self.assertGreater(measured["allocation_calls"], 40000)
+        self.assertLess(measured["allocation_calls"], 200000)
+
+    def test_cpu_and_memory_controls(self):
+        def busy():
+            start = time.process_time_ns()
+            while time.process_time_ns() - start < 25_000_000:
+                pass
+
+        measured = time_operations(busy, 1)
+        self.assertGreaterEqual(measured["process_cpu_time_per_op"], 25_000_000)
+        settle()
+        before = memory()["rss"]
+        retained = bytearray(64 * 1024 * 1024)
+        for i in range(0, len(retained), 4096):
+            retained[i] = 1
+        settle()
+        self.assertGreater(memory()["rss"] - before, 32 * 1024 * 1024)
+        del retained
+        settle()
+
+    def test_refresh_checkpoints_detect_retained_state(self):
+        class Retaining(Posthog):
+            def __init__(self, *args, **kwargs):
+                self.retained = []
+                super().__init__(*args, **kwargs)
+
+            def load_feature_flags(self):
+                result = super().load_feature_flags()
+                block = bytearray(8 * 1024 * 1024)
+                for i in range(0, len(block), 4096):
+                    block[i] = 1
+                self.retained.append(block)
+                return result
+
+        spec = {
+            **next(s for s in workloads(True) if s["mode"] == "refresh"),
+            "operations": 4,
+        }
+        with BenchmarkServer(spec) as server:
+            workload = Workload(spec, server.url, client_class=Retaining)
+            try:
+                settle()
+                before = memory()["rss"]
+                checkpoints = []
+
+                def checkpoint(completed):
+                    settle()
+                    checkpoints.append((completed, memory()["rss"]))
+
+                workload.run(checkpoint=checkpoint)
+                workload.verify()
+                self.assertEqual([point[0] for point in checkpoints], [1, 2, 3, 4])
+                self.assertGreater(checkpoints[-1][1] - before, 24 * 1024 * 1024)
+                self.assertGreater(
+                    checkpoints[-1][1] - checkpoints[0][1], 16 * 1024 * 1024
+                )
+            finally:
+                workload.close()
+
+    def test_public_entry_cpu_and_allocation_regressions(self):
+        class Expensive(Posthog):
+            def get_feature_flag(self, *args, **kwargs):
+                result = super().get_feature_flag(*args, **kwargs)
+                start = time.thread_time_ns()
+                while time.thread_time_ns() - start < 500_000:
+                    pass
+                allocation = bytearray(256 * 1024)
+                allocation[0] = 1
+                return result
+
+        spec = workloads(True)[0]
+        results = []
+        for cls in (Posthog, Expensive):
+            with BenchmarkServer(spec) as server:
+                workload = Workload(spec, server.url, client_class=cls)
+                try:
+                    workload.run()
+                    timing = time_operations(workload.run, spec["operations"])
+                    allocation = sample_allocations(workload.run)
+                    workload.verify()
+                    results.append((timing, allocation))
+                finally:
+                    workload.close()
+        self.assertGreater(
+            results[1][0]["process_cpu_time_per_op"],
+            results[0][0]["process_cpu_time_per_op"] * 3,
+        )
+        self.assertGreater(
+            results[1][1]["allocated_bytes"], results[0][1]["allocated_bytes"] * 3
+        )
+
+    def test_worker_pass_isolation_and_installed_package(self):
+        raw = run_worker(PYTHON, workloads(True)[0], "allocation")
+        self.assertEqual(raw["status"], "ok", raw["stderr"])
+        self.assertNotIn("elapsed_time_per_op", raw)
+        self.assertTrue(Path(raw["entry"]).is_relative_to(ROOT / ".venv-benchmark"))
+        result: dict[str, Any] = {"status": "ok", "metrics": [], "runs": []}
+        append_sample(result, raw, 0)
+        self.assertEqual(result["metrics"][1]["id"], "allocations_per_op")
+        self.assertEqual(result["metrics"][1]["quality"], "measured")
+
+    def test_worker_failures_are_not_zero_cost_samples(self):
+        raw = run_worker(PYTHON, {**workloads(True)[0], "flag_index": 100}, "timing")
+        self.assertEqual(raw["status"], "error")
+        result: dict[str, Any] = {"status": "ok", "metrics": [], "runs": []}
+        append_sample(result, raw, 0)
+        self.assertEqual(result["status"], "error")
+        self.assertEqual(result["metrics"], [])
+        self.assertEqual(
+            run_worker(PYTHON, workloads(True)[0], "timing", timeout=0.01)["status"],
+            "timeout",
+        )
+        limited = run_worker(PYTHON, workloads(True)[0], "timing", rss_limit=1)
+        self.assertTrue(limited["rss_limit_exceeded"])
+        self.assertEqual(limited["status"], "error")
+
+    def test_killed_worker_temporary_files_are_removed_by_the_coordinator(self):
+        with tempfile.TemporaryDirectory() as directory:
+            worker = Path(directory) / "worker.py"
+            worker.write_text(
+                "import tempfile, time\nprint(tempfile.mkdtemp(prefix='profile-'), flush=True)\ntime.sleep(10)\n"
+            )
+            with patch("run.WORKER", worker):
+                raw = run_worker(PYTHON, workloads(True)[0], "allocation", timeout=0.5)
+            self.assertEqual(raw["status"], "timeout")
+            profile = Path(raw["stdout"].strip())
+            self.assertTrue(profile.name.startswith("profile-"))
+            self.assertTrue(profile.parent.name.startswith("posthog-benchmark-worker-"))
+            self.assertFalse(profile.parent.exists())
+
+    def test_repeated_timeouts_stop_the_suite_with_partial_results(self):
+        with (
+            tempfile.TemporaryDirectory() as directory,
+            patch(
+                "run.run_worker", return_value={"status": "timeout", "pass": "timing"}
+            ) as worker,
+        ):
+            code = main(
+                [
+                    "--base",
+                    str(ROOT),
+                    "--head",
+                    str(ROOT),
+                    "--output",
+                    directory,
+                    "--smoke",
+                ]
+            )
+            self.assertEqual(code, 1)
+            self.assertEqual(worker.call_count, 2)
+            for role in ("base", "head"):
+                document = json.loads((Path(directory) / f"{role}.json").read_text())
+                self.assertEqual(len(document["benchmarks"]), 1)
+                self.assertEqual(document["benchmarks"][0]["status"], "timeout")
+                self.assertEqual(document["benchmarks"][0]["metrics"], [])
+                self.assertEqual(len(document["benchmarks"][0]["runs"]), 1)
+
+    def test_oom_classification_requires_evidence(self):
+        self.assertEqual(classify_exit(stderr="Killed"), "error")
+        self.assertEqual(classify_exit(stderr="Traceback...\nMemoryError\n"), "oom")
+        self.assertEqual(classify_exit(rss_limit_exceeded=True), "error")
+        self.assertEqual(classify_exit(timed_out=True), "timeout")
+
+    def test_package_identity_and_source_fingerprints(self):
+        self.assertTrue(Path(environment()["entry"]).is_relative_to(Path(sys.prefix)))
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "module.py"
+            path.write_text("VALUE = 1")
+            before = source_digest(directory)
+            path.write_text("VALUE = 2")
+            self.assertNotEqual(source_digest(directory), before)
+
+    def test_paired_documents(self):
+        with tempfile.TemporaryDirectory() as directory:
+            self.assertEqual(
+                main(
+                    [
+                        "--base",
+                        str(ROOT),
+                        "--head",
+                        str(ROOT),
+                        "--output",
+                        directory,
+                        "--smoke",
+                        "--repetitions",
+                        "2",
+                        "--filter",
+                        "flags.single.boolean",
+                    ]
+                ),
+                0,
+            )
+            base = json.loads((Path(directory) / "base.json").read_text())
+            head = json.loads((Path(directory) / "head.json").read_text())
+            self.assertEqual(base["execution"]["pair_id"], head["execution"]["pair_id"])
+            self.assertEqual(
+                base["execution"]["build_digest"], head["execution"]["build_digest"]
+            )
+            self.assertEqual(
+                base["benchmarks"][0]["fixture_digest"],
+                head["benchmarks"][0]["fixture_digest"],
+            )
+            self.assertEqual(base["revision"]["role"], "base")
+            self.assertEqual(head["revision"]["role"], "head")
+            for metric in head["benchmarks"][0]["metrics"]:
+                self.assertEqual(len(metric["samples"]), 2)
+
+    def test_worker_describes_the_installed_distribution(self):
+        # Validate the actual recorded installation, not source-tree import resolution.
+        output = subprocess.check_output(
+            [PYTHON, "-B", str(ROOT / "benchmarks/worker.py"), "--describe"],
+            cwd=tempfile.gettempdir(),
+        )
+        self.assertEqual(
+            json.loads(output)["build_digest"], environment()["build_digest"]
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/benchmarks/worker.py b/benchmarks/worker.py
new file mode 100644
index 000000000..e8b80f235
--- /dev/null
+++ b/benchmarks/worker.py
@@ -0,0 +1,96 @@
+"""One isolated revision/workload/measurement-pass execution."""
+
+import json
+import sys
+import time
+from pathlib import Path
+
+from measurement import (
+    lifetime_peak_rss,
+    memory,
+    sample_allocations,
+    settle,
+    time_operations,
+)
+from workload import Workload
+
+
+def execute(spec, host):
+    assert sys.flags.optimize == 0, "Benchmark correctness checks require assertions"
+    import posthog
+
+    with_installed_sdk = Path(posthog.__file__).resolve()
+    assert with_installed_sdk.is_relative_to(Path(sys.prefix)), (
+        "Expected the target's installed wheel"
+    )
+    workload = Workload(spec, host)
+    try:
+        warmup = (
+            2
+            if spec["mode"] == "refresh"
+            else min(spec["operations"], 32 if spec.get("flag_count") == 1000 else 160)
+        )
+        workload.run(warmup)
+        workload.verify()
+        settle()
+        operations = (
+            spec.get("allocation_operations", spec["operations"])
+            if spec["pass"] == "allocation"
+            else spec["operations"]
+        )
+        result = {
+            "pass": spec["pass"],
+            "operations": operations,
+            "warmup_operations": warmup,
+            "entry": str(with_installed_sdk),
+        }
+        if spec["pass"] == "timing":
+            result.update(time_operations(workload.run, spec["operations"]))
+            if spec["mode"] == "capture":
+                # Foreground enqueue does not have a public background-preparation completion signal.
+                # Process-wide CPU/allocations for full delivery belong to the drain workload.
+                del result["process_cpu_time_per_op"]
+            else:
+                del result["caller_thread_cpu_time_per_op"]
+        elif spec["pass"] == "allocation":
+            result.update(sample_allocations(lambda: workload.run(operations)))
+        elif spec["pass"] == "memory":
+            result["before"] = memory()
+            result["checkpoints"] = []
+            observed = result["before"]["rss"]
+
+            def checkpoint(completed):
+                nonlocal observed
+                observed = max(observed, memory()["rss"])
+                if spec["mode"] == "refresh" and (
+                    completed % 5 == 0 or completed == spec["operations"]
+                ):
+                    settle()
+                    result["checkpoints"].append({"operations": completed, **memory()})
+
+            start = time.perf_counter_ns()
+            workload.run(checkpoint=checkpoint)
+            result["elapsed_ns"] = time.perf_counter_ns() - start
+            result["after_work"] = memory()
+            result["observed_peak_rss"] = max(observed, result["after_work"]["rss"])
+            result["process_lifetime_peak_rss"] = lifetime_peak_rss()
+            settle()
+            result["after_settling"] = memory()
+        else:
+            raise ValueError(f"Unknown pass {spec['pass']}")
+        result["validation"] = workload.verify()
+        return result
+    finally:
+        workload.close()
+
+
+if __name__ == "__main__":
+    if sys.argv[1:] == ["--describe"]:
+        from identity import environment
+
+        print(json.dumps(environment()))
+    else:
+        spec, host, output = sys.argv[1:]
+        Path(output).write_text(
+            json.dumps(execute(json.loads(spec), host)), encoding="utf-8"
+        )
diff --git a/benchmarks/workload.py b/benchmarks/workload.py
new file mode 100644
index 000000000..069824c77
--- /dev/null
+++ b/benchmarks/workload.py
@@ -0,0 +1,171 @@
+import json
+from concurrent.futures import ThreadPoolExecutor
+from urllib.request import Request, urlopen
+
+from fixtures import CASES, USERS, expected_flags, expected_value
+
+
+def control(host, path, data=None):
+    body = None if data is None else json.dumps(data).encode()
+    request = Request(
+        host + path, data=body, headers={"Content-Type": "application/json"}
+    )
+    with urlopen(request, timeout=5) as response:
+        return json.load(response)
+
+
+class Workload:
+    def __init__(self, spec, host, client_class=None):
+        if client_class is None:
+            from posthog import Posthog
+
+            client_class = Posthog
+        self.spec = spec
+        self.host = host
+        self.generation = 0
+        self.captured = 0
+        self.captured_by_user = {user["distinct_id"]: 0 for user in USERS}
+        self.errors: list[str] = []
+        self.checks = 0
+        self.flags = spec["mode"] in ("single", "all", "refresh")
+        self.client = client_class(
+            "benchmark-project-key",
+            host=host,
+            max_queue_size=100001,
+            flush_at=100000,
+            flush_interval=3600,
+            poll_interval=3600,
+            timeout=5,
+            max_retries=0,
+            feature_flags_request_max_retries=0,
+            gzip=False,
+            capture_mode="v0",
+            thread=1,
+            on_error=lambda error, _batch: self.errors.append(str(error)),
+            **({"personal_api_key": "benchmark-local-only"} if self.flags else {}),
+        )
+        self.pool = (
+            ThreadPoolExecutor(max_workers=spec["concurrency"])
+            if spec["concurrency"] > 1
+            else None
+        )
+        self.events = [
+            {
+                "event": "benchmark",
+                "distinct_id": user["distinct_id"],
+                "properties": {
+                    "payload": "x" * spec.get("payload_bytes", 0),
+                    "plan": "pro",
+                },
+            }
+            for user in USERS
+        ]
+        try:
+            if self.flags:
+                self.check_flags()
+                assert self.state()["definitions"] > 0
+            self.verify()
+        except BaseException:
+            self.close()
+            raise
+
+    def state(self):
+        return control(self.host, "/__benchmark/state")
+
+    def evaluate(self, index):
+        user = USERS[index % len(USERS)]
+        options = {
+            "person_properties": user["person_properties"],
+            "only_evaluate_locally": True,
+        }
+        if self.spec["mode"] == "single":
+            i = self.spec["flag_index"]
+            return self.client.get_feature_flag(
+                f"{CASES[i]}-{i}",
+                user["distinct_id"],
+                send_feature_flag_events=False,
+                **options,
+            )
+        return self.client.get_all_flags(user["distinct_id"], **options)
+
+    def check_flags(self):
+        for i, user in enumerate(USERS):
+            expected = (
+                expected_value(self.spec["flag_index"], user, self.generation)
+                if self.spec["mode"] == "single"
+                else expected_flags(self.spec["flag_count"], user, self.generation)
+            )
+            actual = self.evaluate(i)
+            assert actual == expected, (
+                f"Wrong local evaluation for {self.spec['id']}, user {i}, generation {self.generation}"
+            )
+            self.checks += 1
+
+    def run(self, operations=None, checkpoint=None):
+        operations = self.spec["operations"] if operations is None else operations
+        mode = self.spec["mode"]
+        if mode == "refresh":
+            for i in range(operations):
+                self.generation += 1
+                control(
+                    self.host,
+                    "/__benchmark/definitions",
+                    {"generation": self.generation},
+                )
+                before = self.state()["definitions"]
+                self.client.load_feature_flags()
+                assert self.state()["definitions"] == before + 1
+                self.check_flags()
+                if checkpoint:
+                    checkpoint(i + 1)
+        elif mode in ("capture", "drain"):
+            for i in range(operations):
+                event = self.events[i % len(self.events)]
+                assert self.client.capture(**event) is not None, (
+                    "Capture rejected an event"
+                )
+                self.captured += 1
+                self.captured_by_user[USERS[i % len(USERS)]["distinct_id"]] += 1
+                if (i + 1) % 100 == 0 or i + 1 == operations:
+                    if mode == "drain":
+                        self.client.flush(timeout_seconds=None)
+                    if checkpoint:
+                        checkpoint(i + 1)
+        else:
+            for start in range(0, operations, self.spec["concurrency"]):
+                if self.pool:
+                    # Bound pending work and discard completed results; this is GIL-constrained threading.
+                    futures = [
+                        self.pool.submit(self.evaluate, i)
+                        for i in range(
+                            start, min(start + self.spec["concurrency"], operations)
+                        )
+                    ]
+                    for future in futures:
+                        future.result()
+                else:
+                    self.evaluate(start)
+                if checkpoint and start % 32 == 0:
+                    checkpoint(min(start + self.spec["concurrency"], operations))
+
+    def verify(self):
+        if self.flags:
+            self.check_flags()
+        elif self.spec["mode"] == "capture":
+            self.client.flush(timeout_seconds=5)
+        state = self.state()
+        assert not self.errors, self.errors
+        assert not state["unexpected"], state["unexpected"]
+        assert state["delivered"] == self.captured, (
+            "Delivered counts must match captures"
+        )
+        assert state["invalid_events"] == 0, "Capture payload or identity changed"
+        assert state["delivered_by_user"] == self.captured_by_user, (
+            "Capture identity distribution changed"
+        )
+        return {**state, "captured": self.captured, "evaluations": self.checks}
+
+    def close(self):
+        if self.pool:
+            self.pool.shutdown(wait=True)
+        self.client.shutdown()

From db52a785f2d40f6813f25309fd2a7ea3e28aa59a Mon Sep 17 00:00:00 2001
From: Dustin Byrne <dustin@posthog.com>
Date: Wed, 4 Nov 2026 16:07:10 -0500
Subject: [PATCH 179/245] ci: integrate shared Python benchmark reports (#1135)

* ci: integrate shared Python benchmark reports

* fix(ci): report aborted benchmark suites and retain pending publishers

* fix(ci): run every PR benchmark with organization-owned reporting

* chore(ci): advance benchmark reporting pins

* test(benchmarks): align with shared workload specification

* ci(benchmarks): shard paired Python workloads

* ci: update SDK benchmark reporting pins

* ci: pin benchmark diagnostics link fix

* ci: pin SDK benchmark reporting to mainline

* fix: preserve benchmark failure reports after timeouts
---
 .github/workflows/benchmark-report.yml |  21 +
 .github/workflows/benchmarks.yml       |  77 +++-
 benchmarks/README.md                   |  41 +-
 benchmarks/fixtures.py                 |  13 +-
 benchmarks/identity.py                 |   5 +-
 benchmarks/run.py                      | 114 +++++-
 benchmarks/server.py                   |  42 +-
 benchmarks/shards.json                 |  39 ++
 benchmarks/test_benchmarks.py          | 530 +++++++++++++++++++++++--
 benchmarks/worker.py                   |  17 +-
 benchmarks/workload.py                 |  72 +++-
 11 files changed, 854 insertions(+), 117 deletions(-)
 create mode 100644 .github/workflows/benchmark-report.yml
 create mode 100644 benchmarks/shards.json

diff --git a/.github/workflows/benchmark-report.yml b/.github/workflows/benchmark-report.yml
new file mode 100644
index 000000000..7fabe81e1
--- /dev/null
+++ b/.github/workflows/benchmark-report.yml
@@ -0,0 +1,21 @@
+name: Python SDK benchmark report
+
+on:
+    workflow_run:
+        workflows: ['Python SDK benchmarks']
+        types: [completed]
+
+permissions: {}
+
+jobs:
+    report:
+        permissions:
+            contents: read
+            actions: read
+            pull-requests: write
+        uses: PostHog/.github/.github/workflows/sdk-benchmark-report.yml@3322f26f21f088ad5e5960d65a916971e309ac0b # SDK benchmark workflow (PostHog/.github PR #84)
+        with:
+            workflow-path: .github/workflows/benchmarks.yml
+            artifact-name: python-benchmark-results
+            report-key: posthog-python
+            sdk: posthog-python
diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index eecd98490..97b769661 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -1,14 +1,6 @@
 name: Python SDK benchmarks
 
-on:
-    pull_request:
-        paths:
-            - 'posthog/**'
-            - 'benchmarks/**'
-            - 'pyproject.toml'
-            - 'setup.py'
-            - 'uv.lock'
-            - '.github/workflows/benchmarks.yml'
+on: [pull_request]
 
 permissions: {}
 
@@ -19,7 +11,11 @@ concurrency:
 jobs:
     benchmark:
         runs-on: ubuntu-24.04
-        timeout-minutes: 30
+        timeout-minutes: 10
+        strategy:
+            fail-fast: false
+            matrix:
+                shard: [flags-single, flags-scaling, flags-memory, capture]
         permissions:
             contents: read
         steps:
@@ -61,12 +57,67 @@ jobs:
               run: .venv-benchmark/bin/python -B benchmarks/test_benchmarks.py
 
             - name: Measure paired base and head
+              id: measure
+              timeout-minutes: 8
               run: |
                   .venv-benchmark/bin/python -B benchmarks/run.py \
                     --base "$BASE_WORKTREE" \
                     --head "$GITHUB_WORKSPACE" \
                     --output "$RESULTS" \
-                    --repetitions 6
+                    --repetitions 6 \
+                    --shard "${{ matrix.shard }}"
+
+            - name: Upload raw shard results
+              if: always()
+              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              with:
+                  name: benchmark-shard-${{ matrix.shard }}
+                  path: |
+                      ${{ runner.temp }}/python-benchmark-results/base.json
+                      ${{ runner.temp }}/python-benchmark-results/head.json
+                      ${{ runner.temp }}/python-benchmark-results/revisions.json
+                  if-no-files-found: warn
+                  retention-days: 14
+
+    collect:
+        needs: benchmark
+        if: ${{ !cancelled() }}
+        runs-on: ubuntu-24.04
+        timeout-minutes: 5
+        permissions:
+            contents: read
+        steps:
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+              with:
+                  ref: ${{ github.event.pull_request.head.sha }}
+                  persist-credentials: false
+
+            - name: Download shard results
+              uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+              with:
+                  pattern: benchmark-shard-*
+                  path: ${{ runner.temp }}/python-benchmark-shards
+                  merge-multiple: false
+
+            - name: Collect and render benchmark comparison
+              uses: PostHog/.github/.github/actions/benchmark-report@3322f26f21f088ad5e5960d65a916971e309ac0b # SDK benchmark reporting (PostHog/.github PR #84)
+              with:
+                  mode: collect
+                  source-status: ${{ needs.benchmark.result }}
+                  shard-manifest: benchmarks/shards.json
+                  shard-directory: ${{ runner.temp }}/python-benchmark-shards
+                  output-directory: ${{ runner.temp }}/python-benchmark-report
+
+            - name: Upload rendered comparison
+              if: always()
+              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              with:
+                  name: python-benchmark-report
+                  path: |
+                      ${{ runner.temp }}/python-benchmark-report/report.md
+                      ${{ runner.temp }}/python-benchmark-report/comparison.json
+                  if-no-files-found: ignore
+                  retention-days: 14
 
             - name: Upload raw benchmark results
               if: always()
@@ -74,7 +125,9 @@ jobs:
               uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
               with:
                   name: python-benchmark-results
-                  path: ${{ runner.temp }}/python-benchmark-results
+                  path: |
+                      ${{ runner.temp }}/python-benchmark-report/bundle.json
+                      ${{ runner.temp }}/python-benchmark-report/revisions.json
                   if-no-files-found: warn
                   retention-days: 14
 
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 8ca37a758..d428c862e 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -1,6 +1,6 @@
 # Python SDK benchmarks
 
-PR-only, paired measurements of independently installed Python SDK revisions. Each workload/pass/repetition runs in a fresh process against the target's non-editable wheel. Benchmark code comes from one checkout and emits `base.json` and `head.json` in the Node pilot's result structure.
+PR-only, paired measurements of independently installed Python SDK revisions. Each workload/pass/repetition runs in a fresh process against the target's non-editable wheel. Benchmark code comes from one checkout and emits `base.json` and `head.json` using the shared reporting contract. Suite version 2 implements [sdk-benchmarks/v1](https://github.com/PostHog/.github/blob/main/.github/workflows/sdk-benchmark-specification.md).
 
 ## Setup and local execution
 
@@ -26,7 +26,7 @@ Run the controls and benchmarks using the head environment:
   --repetitions 6
 ```
 
-`--smoke --repetitions 1` checks integration quickly; smoke results are not suitable for performance conclusions. `--filter flags.all.` selects workload IDs by prefix. Using the same revision on both sides measures repeatability, not an improvement.
+`--smoke --repetitions 1` checks integration quickly; smoke results are not suitable for performance conclusions. `--filter flags.all.` selects workload IDs by prefix. `--shard flags-single` selects one fixed group from `shards.json`: `flags-single`, `flags-scaling`, `flags-memory`, or `capture`. Shard selection and prefix filtering are mutually exclusive; omitting both runs the full inventory. The manifest must partition both full and smoke inventories exactly, without duplicate workloads. Each invocation creates a fresh pair ID for its own base/head documents. Using the same revision on both sides measures repeatability, not an improvement.
 
 Rerun preparation after changing SDK source. Preparation forces a `posthog` rebuild/reinstall so source-only changes cannot reuse uv's cached wheel. The worker deliberately does not import the repository source tree. Results fingerprint the installed package's Python files and record its entry path, SDK commit/dirty state, package version, lockfile digest, actual installed dependency/tool versions, benchmark source digest, runtime, fixture digest, and paired-run ID.
 
@@ -44,37 +44,40 @@ uv pip compile benchmarks/requirements.in --python-version 3.12 --universal \
 | Nine single-flag cases | `get_feature_flag` | Elapsed time/op, process CPU/op, Python allocator bytes/calls per op |
 | All flags: 10, 100, 1,000 | `get_all_flags` | Same metrics per complete all-flags call |
 | Sustained 1,000-flag evaluation | Eight threads calling `get_all_flags` | RSS observations and post-settling RSS |
-| Forty definition refreshes | `load_feature_flags`, then validated `get_all_flags` | Memory checkpoints every five cycles and at the end |
+| Forty definition refreshes | `load_feature_flags` | Memory checkpoints after every refresh |
 | Capture: 32-byte and 4,096-byte string properties | `capture` | Foreground elapsed time and caller-thread CPU per event |
-| Capture and drain: both payload sizes | `capture`, `flush` every 100 events | Full-pipeline time, process CPU, allocator bytes/calls, and memory |
+| Steady delivery: both payload sizes | `capture`, `flush` every 100 events | Full-pipeline time, process CPU, allocator bytes/calls, and memory |
+| Burst delivery: both payload sizes | `capture`, one final `flush` | Full-pipeline time, process CPU, allocator bytes/calls, and memory |
 
-The flag mix and sixteen identities match the Node pilot conceptually: boolean, percentage rollout, multivariate assignment, person properties, regex, cohort, early/late/no-match, and inactive flags. Expected values are computed independently of the SDK. Every identity is validated before and after measurement. Refresh generations alter actual boolean/cohort results and regex patterns so a fetch without a state update fails validation.
+The 20 workload IDs and operation counts follow the specification. Full single-flag workloads use 16,000 evaluations; all-flags workloads use 1,600/160/160 for 10/100/1,000 definitions. Allocation passes use 2,000 single-flag and 160/16/16 all-flags evaluations, with the actual denominator recorded. Load uses 1,600 evaluations; refresh uses 40 reloads. Every capture workload and pass uses 1,000 events. Smoke uses 160 single-flag, 16 all-flags, 32 load evaluations, four refreshes, and 200 captures.
+
+The flag mix and sixteen identities follow the shared fixtures: boolean, percentage rollout, multivariate assignment, person properties, regex, cohort, early/late/no-match, and inactive flags. Expected values are computed independently of the SDK. Every identity is validated before and after measurement. All measured flag phases start at generation 0, restored through public reload after warmup. Refreshes load generations 1–40 (1–4 for smoke), checking each definitions request. Full result sweeps occur before and after measurement, not inside the refresh loop. Controls separately check every changing generation and reload result.
 
 The suite covers the supported legacy flag getters, not `evaluate_flags` snapshots. Deprecation warnings are encountered during setup. Eight threads are **GIL-constrained concurrency**, not a claim of eight-way parallel Python execution.
 
 ### Transport and lifecycle
 
-Python has no public fetch adapter. A bounded loopback HTTP server runs in the coordinator process, outside the measured worker, and serves definitions and accepts uncompressed v0 batches. Its routes are limited to the fixture protocol and a control/inspection interface. It retains counters and per-identity counts, not event history. Remote flag fallback is unexpected and fails verification.
+Python has no public fetch adapter. A bounded loopback HTTP server runs in the coordinator process, outside the measured worker, and serves definitions and accepts uncompressed v0 batches. Its routes are limited to the fixture protocol and a control/inspection interface. It retains bounded counters, per-identity counts, and a preallocated sequence bitmap, not event history. Remote flag fallback is unexpected and fails verification.
 
 The SDK uses real requests, JSON parsing/serialization, background consumers, flag loading, flush, and shutdown. No private queue, evaluator, or poller is replaced. Automatic polling and partial-batch deadlines are set to one hour, longer than the worker timeout. Refreshes and draining use public methods. Worker shutdown must stop SDK threads.
 
-Capture checks require the correct event name, exact payload, identity distribution, and total delivered count. Rejected captures, timeouts that leave undelivered events, malformed payloads, and remote fallback cannot appear as successful low-cost work.
+Capture fixtures are preconstructed outside measurement: event `benchmark`, identity `benchmark-user-<sequence modulo 16>`, and separate caller-owned property dictionaries containing exactly 32 or 4,096 ASCII `x` characters as `payload`, `plan=pro`, and integer `sequence`. Warmup delivery is flushed and verified before receiver/capture state is reset; measured sequences restart at zero. Capture checks require the correct event name, exact payload and plan, sequence-to-identity mapping, and exactly one delivery of each expected sequence. Balanced loss/duplication fails even with matching totals and per-user counts; arrival order is unrestricted. Rejected captures, timeouts that leave undelivered events, malformed payloads, and remote fallback cannot appear as successful low-cost work.
 
 ### Capture measurement boundaries
 
 `capture()` returns after foreground preparation/enqueue, while a consumer can concurrently prepare its batch. There is no public completion boundary for that background preparation short of flushing. Therefore:
 
-- `capture.enqueue.*` reports foreground elapsed time and **caller-thread CPU**, not process-wide CPU or allocation totals.
-- `capture.drain.*` includes `flush(timeout_seconds=None)` and reports the complete delivery path's process CPU and allocations, including requests/serialization. The external worker timeout bounds this wait. Verification does not flush again: unfinished measured work cannot be rescued outside the measurement. Server CPU and server allocations are excluded; elapsed time includes loopback transport.
+- `capture.enqueue.*` records `completion_boundary=api_return` and reports foreground elapsed time and **caller-thread CPU**, not process-wide CPU or allocation totals. Its explicit flush and delivery checks occur afterward, outside measurement.
+- `capture.drain.steady.*` and `capture.drain.burst.*` record `completion_boundary=completed_delivery`. Steady flushes every 100 captures; burst flushes once after all captures. Parameters record `drain_strategy` and `flush_every`. Both include `flush(timeout_seconds=None)` and reports the complete delivery path's process CPU and allocations, including requests/serialization. The external worker timeout bounds this wait. Verification does not flush again: unfinished measured work cannot be rescued outside the measurement. Server CPU and server allocations are excluded; elapsed time includes loopback transport.
 - Enqueue-only allocation metrics are explicitly unavailable and direct readers to the drain workload.
 
-The enqueue workload uses 1,000 events, below queue/batch-count limits; partial batches can still be prepared by the consumer. These metrics describe their named paths rather than pretending Python and Node have identical asynchronous lifecycles.
+Capture uses public options `gzip=False`, `capture_mode="v0"`, `max_queue_size=100001`, `flush_at=100000`, and one-hour flush/poll intervals. The native consumer and size-driven batching remain active: burst describes the caller flush schedule, not retained queue size or a guaranteed HTTP request count. These metrics describe their named paths rather than pretending Python and Node have identical asynchronous lifecycles.
 
 ## Measurement methods
 
 Base/head alternate first position between independent repetitions and never benchmark concurrently. The same head-side fixtures and measurement code run against both installations. The runner verifies matching Python, profiler, psutil, OS, and architecture versions. Both workers use a fixed hash seed and a clean Python configuration environment.
 
-Warmup and correctness checks happen outside timing. Timing, allocation profiling, and memory observation are separate passes. Allocation passes use smaller fixed operation counts where tracing every Python allocation would otherwise produce excessive profiler files; the actual count is included in each result and used as its denominator. These counts are identical for base and head.
+Warmup and correctness checks happen outside measurement. Warmup uses two refreshes, otherwise the smaller of the operation count and 32 (1,000-flag workloads) or 160 (other workloads); both revisions use the same policy. Timing, allocation profiling, and memory observation are separate passes. Allocation passes use smaller fixed operation counts where tracing every Python allocation would otherwise produce excessive profiler files; the actual count is included in each result and used as its denominator. These counts are identical for base and head.
 
 ### Time and CPU
 
@@ -95,23 +98,25 @@ Memray runs with `trace_python_allocators=True` and `FileFormat.ALL_ALLOCATIONS`
 
 Profiler capture and aggregation do not contribute to reported timing. Profiles are streamed and removed after aggregation so repeated runs do not retain large binary captures. Raw counters and profiler versions remain in the JSON.
 
-The control suite demonstrates that this configuration records freed small allocations that default Memray tracking does not expose as Python allocator requests. Other controls preserve SDK outputs while adding CPU work and allocation churn; both must be detected. See [Memray's allocator documentation](https://bloomberg.github.io/memray/python_allocators.html) and [API documentation](https://bloomberg.github.io/memray/api.html).
+The controls also cover full/smoke inventory, flush schedules, phase reset and input ownership, reordered delivery, balanced duplicates/loss, failed delivery without a rescuing flush, refresh resets, and deterministic memory checkpoints. The control suite demonstrates that this configuration records freed small allocations that default Memray tracking does not expose as Python allocator requests. Other controls preserve SDK outputs while adding CPU work and allocation churn; both must be detected. See [Memray's allocator documentation](https://bloomberg.github.io/memray/python_allocators.html) and [API documentation](https://bloomberg.github.io/memray/api.html).
 
 ### Memory
 
 - Idle RSS: after imports, definitions, validation, warmup, and settling.
-- Observed workload peak RSS: operation checkpoints and end-of-work observation; can miss intervening spikes.
+- Observed workload peak RSS: maximum of before-work, operation checkpoints, and end-of-work observations; can miss intervening spikes. Checkpoints follow each 32 completed load evaluations, each refresh, or each 100 captures, including a final partial interval. Steady checkpoints follow scheduled flushes; burst checkpoints precede its final flush. A separate after-work snapshot includes completed delivery.
 - Lifetime peak RSS: `resource.getrusage`, normalized from platform-specific units. Includes setup and warmup, not just measured work.
 - Post-settling RSS: after two `gc.collect()` calls separated by a scheduler yield. Python reference counting also frees objects during ordinary execution.
 
-CPython has no uninstrumented total managed-heap byte counter equivalent to Node's `heapUsed`. `post_settling_heap_used` is explicitly unsupported; enabling tracing in the RSS pass would change the measurement. Retained RSS alone does not prove a leak because allocators can keep arenas resident. A public-entry control deliberately retains 8 MiB on each refresh and verifies that post-GC checkpoints expose the growth.
+CPython has no uninstrumented total managed-heap byte counter equivalent to Node's `heapUsed`. `post_settling_heap_used` is explicitly unsupported; enabling tracing in the RSS pass would change the measurement. Retained RSS alone does not prove a leak because allocators can keep arenas resident. Natural GC stays enabled, but no forced GC runs during work or checkpoint callbacks. Explicit settling occurs before and after memory measurement; final correctness sweeps follow the post-settling snapshot. A public-entry control deliberately retains 8 MiB on each refresh and verifies that checkpoint RSS exposes the growth.
 
-Each worker has a two-minute timeout and an externally monitored **512 MiB RSS ceiling**, checked approximately every 20 ms. This is a safety bound, not an exact OS-enforced limit: short spikes can exceed it between observations. A ceiling violation is reported as `error` with `rss_limit_exceeded`, not falsely described as a confirmed OS OOM. An explicit Python `MemoryError` is classified as OOM; a generic kill is not. The suite stops after two worker timeouts, after completing the current base/head pair, and preserves partial results for upload. Worker temporary files, including profiler traces, are owned and removed by the coordinator even when a worker is killed.
+SDK identity subprocesses have a two-minute deadline. Each worker has a two-minute timeout and an externally monitored **512 MiB RSS ceiling**, checked approximately every 20 ms. This is a safety bound, not an exact OS-enforced limit: short spikes can exceed it between observations. A ceiling violation is reported as `error` with `rss_limit_exceeded`, not falsely described as a confirmed OS OOM. An explicit Python `MemoryError` is classified as OOM; a generic kill is not. The suite stops after two worker timeouts, after completing the current base/head pair, and preserves partial results for upload. Results retain the complete selected workload inventory: unvisited workloads are marked `error` with a not-run reason and no samples, so the failed shard can still be collected and published. Worker temporary files, including profiler traces, are owned and removed by the coordinator even when a worker is killed.
 
 ## Results and CI
 
-The pilot JSON format uses `schema_version: 1`, with the same top-level revision, suite, execution, benchmark, metric, sample, and status structure as Node. Measurement IDs, units, method names, and quality are explicit. Python's intentional differences are allocator-call counts, foreground-thread CPU for enqueue, unavailable uninstrumented heap size, and a separate HTTP receiver. Shared schema finalization and rendering are separate work.
+The shared JSON format uses `schema_version: 1`, with the same top-level revision, suite, execution, benchmark, metric, sample, and status structure as Node. Measurement IDs, units, method names, and quality are explicit. Python's intentional differences are allocator-call counts, foreground-thread CPU for enqueue, unavailable uninstrumented heap size, and a separate HTTP receiver. The contract, semantic validation, comparisons, and rendering live in [PostHog/.github](https://github.com/PostHog/.github/blob/main/.github/workflows/sdk-benchmark-report.md).
+
+The workflow runs for every pull request opened, reopened, or updated in `PostHog/posthog-python`. Four independent runner jobs build the merge base and exact head into isolated environments and each run one fixed shard. All six alternating paired repetitions and native measurement passes for a workload stay on one runner, with fresh worker processes and no same-host measurement concurrency. Shard jobs have a ten-minute safety timeout, with an eight-minute measurement step limit to leave time for artifact upload, and do not cancel siblings on failure. Each uploads `base.json`, `head.json`, and `revisions.json` in its own `benchmark-shard-<id>` artifact, including available partial results after failure.
 
-The PR workflow builds the merge base and exact head into isolated environments, then runs this head-side suite against both. It requests read-only permissions, uses pinned actions, requires no service credentials, preserves partial results after worker failures, and uploads JSON artifacts linked from the job summary.
+A separate read-only, five-minute collection job downloads the shard artifacts and invokes the SHA-pinned reporting action in `PostHog/.github` with the head-side manifest and matrix result. It validates complete coverage and renders one comparison in the job summary; a failed source job suppresses numeric comparisons. Suite metadata, including the source digest covering `shards.json`, is identical across shards. Each document records its shard as `execution.shard_id`, retaining each runner's environment and SDK build identity. The canonical `python-benchmark-results` artifact contains only `bundle.json` and `revisions.json`; Markdown and comparison JSON are uploaded separately as `python-benchmark-report`. The workflow requests read-only permissions, uses pinned actions, and requires no service credentials.
 
-Correctness failures and broken execution fail the job. Performance differences do not: this producer does not compute regression verdicts. Shared comparisons, noise classification, and PR comments remain separate. Calibrate on the actual Linux runner before introducing performance gates; local macOS results are not a CI noise floor.
+Correctness failures and broken execution fail the job. Performance differences do not: this producer does not compute regression verdicts. Comparisons expose descriptive medians and variability rather than calibrated regression verdicts. A separate `workflow_run` caller uses the SHA-pinned reusable workflow in `PostHog/.github` to verify source-run/artifact/PR identities and publish comments without executing PR code with write permissions. This caller must land on the default branch before automatic comments are active, including for fork PRs. Calibrate on the actual Linux runner before introducing performance gates; local macOS results are not a CI noise floor.
diff --git a/benchmarks/fixtures.py b/benchmarks/fixtures.py
index a59599584..e85a8f57f 100644
--- a/benchmarks/fixtures.py
+++ b/benchmarks/fixtures.py
@@ -1,4 +1,4 @@
-"""Deterministic fixtures matching the Node pilot's flag mix and identities."""
+"""Deterministic fixtures for sdk-benchmarks/v1."""
 
 import hashlib
 import json
@@ -189,7 +189,8 @@ def workloads(smoke=False):
                 "id": f"capture.enqueue.{size}",
                 "mode": "capture",
                 "payload_bytes": size,
-                "operations": 100 if smoke else 1000,
+                "operations": 200 if smoke else 1000,
+                "completion_boundary": "api_return",
                 "concurrency": 1,
                 "passes": ["timing"],
             }
@@ -197,13 +198,19 @@ def workloads(smoke=False):
         ],
         *[
             {
-                "id": f"capture.drain.{size}",
+                "id": f"capture.drain.{strategy}.{size}",
                 "mode": "drain",
+                "drain_strategy": strategy,
+                "flush_every": 100
+                if strategy == "steady"
+                else (200 if smoke else 1000),
+                "completion_boundary": "completed_delivery",
                 "payload_bytes": size,
                 "operations": 200 if smoke else 1000,
                 "concurrency": 1,
                 "passes": ["timing", "allocation", "memory"],
             }
+            for strategy in ("steady", "burst")
             for size in (32, 4096)
         ],
     ]
diff --git a/benchmarks/identity.py b/benchmarks/identity.py
index 6e77152b8..263f4d91a 100644
--- a/benchmarks/identity.py
+++ b/benchmarks/identity.py
@@ -13,7 +13,10 @@ def source_digest(directory):
             str(path.relative_to(directory)): digest(path.read_bytes())
             for path in sorted(directory.rglob("*"))
             if path.is_file()
-            and path.suffix in (".py", ".txt", ".in")
+            and (
+                path.suffix in (".py", ".txt", ".in")
+                or path == directory / "shards.json"
+            )
             and "__pycache__" not in path.parts
         }
     )
diff --git a/benchmarks/run.py b/benchmarks/run.py
index d7fb14f91..f3eca2d4c 100644
--- a/benchmarks/run.py
+++ b/benchmarks/run.py
@@ -4,6 +4,7 @@
 import json
 import math
 import os
+import re
 import subprocess
 import sys
 import tempfile
@@ -25,6 +26,47 @@
 RSS_LIMIT = 512 * 1024 * 1024
 
 
+def load_shards(path=HERE / "shards.json"):
+    manifest = json.loads(path.read_text())
+    if (
+        not isinstance(manifest, dict)
+        or set(manifest) != {"manifest_version", "sdk", "shards"}
+        or type(manifest["manifest_version"]) is not int
+        or manifest["manifest_version"] != 1
+        or manifest["sdk"] != "posthog-python"
+        or not isinstance(manifest["shards"], list)
+        or not 1 <= len(manifest["shards"]) <= 16
+    ):
+        raise ValueError("Invalid shard manifest")
+    shards = {}
+    assigned = []
+    for shard in manifest["shards"]:
+        if (
+            not isinstance(shard, dict)
+            or set(shard) != {"id", "workloads"}
+            or not isinstance(shard["id"], str)
+            or not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", shard["id"])
+            or shard["id"] in shards
+            or not isinstance(shard["workloads"], list)
+            or not shard["workloads"]
+            or not all(isinstance(item, str) for item in shard["workloads"])
+        ):
+            raise ValueError("Invalid or duplicate shard")
+        shards[shard["id"]] = shard["workloads"]
+        assigned.extend(shard["workloads"])
+    for smoke in (False, True):
+        inventory = [spec["id"] for spec in workloads(smoke)]
+        if (
+            len(set(assigned)) != len(assigned)
+            or len(set(inventory)) != len(inventory)
+            or set(assigned) != set(inventory)
+        ):
+            raise ValueError(
+                "Shard workloads must exactly partition full and smoke inventories"
+            )
+    return shards
+
+
 def worker_env():
     env = {
         key: value for key, value in os.environ.items() if not key.startswith("PYTHON")
@@ -136,6 +178,7 @@ def document_for(directory, role, pair_id, suite):
                 cwd=cwd,
                 env=worker_env(),
                 text=True,
+                timeout=TIMEOUT,
             )
         )
     execution.update(
@@ -297,19 +340,32 @@ def main(args=None):
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--repetitions", type=int, default=6, choices=range(1, 31))
     parser.add_argument("--smoke", action="store_true")
-    parser.add_argument("--filter", default="")
+    selection = parser.add_mutually_exclusive_group()
+    selection.add_argument("--filter", default="")
+    selection.add_argument("--shard")
     options = parser.parse_args(args)
+    try:
+        shards = load_shards()
+    except ValueError as error:
+        parser.error(str(error))
+    if options.shard is not None and options.shard not in shards:
+        parser.error(f"Unknown shard: {options.shard}")
     specs = [
         spec
         for spec in workloads(options.smoke)
-        if spec["id"].startswith(options.filter)
+        if (
+            spec["id"] in shards[options.shard]
+            if options.shard is not None
+            else spec["id"].startswith(options.filter)
+        )
     ]
     if not specs:
         parser.error("No matching workloads")
     pair_id = str(uuid.uuid4())
     suite = {
         "id": "python-sdk-performance",
-        "version": 1,
+        "version": 2,
+        "specification": "sdk-benchmarks/v1",
         "source_commit": git(HERE, "rev-parse", "HEAD"),
         "source_digest": source_digest(HERE),
         "profile": "smoke" if options.smoke else "full",
@@ -320,13 +376,15 @@ def main(args=None):
             "scope": "PYMALLOC_MALLOC/CALLOC/REALLOC requests; all worker threads",
         },
         "transport": "loopback HTTP receiver in coordinator process; uncompressed v0",
+        "warmup": "two refreshes; otherwise min(operations, 32 for 1000 flags or 160); verified phase reset before measurement",
         "settling": "two gc.collect calls separated by sleep(0)",
         "memory_sampling": "operation checkpoints; lifetime high-water mark includes setup and warmup",
         "capture": {
             "flush_at": 100000,
             "flush_interval_seconds": 3600,
             "consumer_threads": 1,
-            "drain_every": 100,
+            "max_queue_size": 100001,
+            "compression": "none",
         },
         "flag_poll_interval_seconds": 3600,
     }
@@ -335,9 +393,35 @@ def main(args=None):
         role: document_for(directory, role, pair_id, suite)
         for role, directory in directories.items()
     }
+    if options.shard is not None:
+        for document in documents.values():
+            document["execution"]["shard_id"] = options.shard
     for key in ("runtime_version", "measurement_tools", "os", "arch"):
         if documents["base"]["execution"][key] != documents["head"]["execution"][key]:
             raise ValueError(f"Base/head {key} differ")
+    for document in documents.values():
+        document["benchmarks"] = [
+            {
+                "id": spec["id"],
+                "parameters": spec,
+                "fixture_digest": digest(
+                    {
+                        "spec": spec,
+                        "definitions": (
+                            definitions(spec["flag_count"])
+                            if "flag_count" in spec
+                            else None
+                        ),
+                        "users": USERS,
+                    }
+                ),
+                "status": "error",
+                "reason": "Workload was not run: suite stopped before reaching it",
+                "metrics": [],
+                "runs": [],
+            }
+            for spec in specs
+        ]
     options.output.mkdir(parents=True, exist_ok=True)
 
     def save():
@@ -348,26 +432,12 @@ def save():
 
     failures = 0
     timeouts = 0
-    for spec in specs:
+    for index, spec in enumerate(specs):
         records = {}
         for role in directories:
-            records[role] = {
-                "id": spec["id"],
-                "parameters": spec,
-                "fixture_digest": digest(
-                    {
-                        "spec": spec,
-                        "definitions": definitions(spec["flag_count"])
-                        if "flag_count" in spec
-                        else None,
-                        "users": USERS,
-                    }
-                ),
-                "status": "ok",
-                "metrics": [],
-                "runs": [],
-            }
-            documents[role]["benchmarks"].append(records[role])
+            records[role] = documents[role]["benchmarks"][index]
+            records[role]["status"] = "ok"
+            del records[role]["reason"]
         for repetition in range(options.repetitions):
             for measurement_pass in spec["passes"]:
                 for role in ["head", "base"] if repetition % 2 else ["base", "head"]:
diff --git a/benchmarks/server.py b/benchmarks/server.py
index b513791bf..b119c2ff9 100644
--- a/benchmarks/server.py
+++ b/benchmarks/server.py
@@ -20,11 +20,15 @@ def __init__(self, spec, batch_delay=0):
         self.lock = threading.Lock()
         self.payload = "x" * spec.get("payload_bytes", 0)
         self.body = json.dumps(definitions(spec.get("flag_count", 0))).encode()
+        self.seen = bytearray(spec["operations"])
+        self.expected_sequences = 0
         self.state: dict[str, Any] = {
             "definitions": 0,
             "delivered": 0,
             "requests": 0,
             "invalid_events": 0,
+            "unique_sequences": 0,
+            "missing_sequences": 0,
             "delivered_by_user": {user["distinct_id"]: 0 for user in USERS},
             "unexpected": [],
         }
@@ -65,7 +69,29 @@ def do_POST(self):
                         if not 0 < size <= 20 * 1024 * 1024:
                             raise ValueError("Invalid body length")
                         body = json.loads(self.rfile.read(size))
-                        if path == "/__benchmark/definitions":
+                        if path == "/__benchmark/reset":
+                            operations = body["operations"]
+                            if (
+                                type(operations) is not int
+                                or not 0 <= operations <= spec["operations"]
+                            ):
+                                raise ValueError("Invalid phase operations")
+                            owner.seen[:] = bytes(len(owner.seen))
+                            owner.expected_sequences = operations
+                            owner.state.update(
+                                definitions=0,
+                                delivered=0,
+                                requests=0,
+                                invalid_events=0,
+                                unique_sequences=0,
+                                missing_sequences=operations,
+                                delivered_by_user={
+                                    user["distinct_id"]: 0 for user in USERS
+                                },
+                                unexpected=[],
+                            )
+                            self.reply(200, b"{}")
+                        elif path == "/__benchmark/definitions":
                             generation = body["generation"]
                             if (
                                 not isinstance(generation, int)
@@ -87,15 +113,29 @@ def do_POST(self):
                             for event in batch:
                                 properties = event.get("properties", {})
                                 user = event.get("distinct_id")
+                                sequence = properties.get("sequence")
+                                valid_sequence = (
+                                    type(sequence) is int
+                                    and 0 <= sequence < owner.expected_sequences
+                                )
                                 if (
                                     event.get("event") != "benchmark"
                                     or user not in owner.state["delivered_by_user"]
                                     or properties.get("payload") != owner.payload
                                     or properties.get("plan") != "pro"
+                                    or not valid_sequence
+                                    or user
+                                    != USERS[sequence % len(USERS)]["distinct_id"]
                                 ):
                                     owner.state["invalid_events"] += 1
                                 else:
                                     owner.state["delivered_by_user"][user] += 1
+                                    if owner.seen[sequence]:
+                                        owner.state["invalid_events"] += 1
+                                    else:
+                                        owner.seen[sequence] = 1
+                                        owner.state["unique_sequences"] += 1
+                                        owner.state["missing_sequences"] -= 1
                             self.reply(200, b'{"status":1}')
                         else:
                             self.unexpected(path)
diff --git a/benchmarks/shards.json b/benchmarks/shards.json
new file mode 100644
index 000000000..faa3085ac
--- /dev/null
+++ b/benchmarks/shards.json
@@ -0,0 +1,39 @@
+{
+  "manifest_version": 1,
+  "sdk": "posthog-python",
+  "shards": [
+    {
+      "id": "flags-single",
+      "workloads": [
+        "flags.single.boolean",
+        "flags.single.rollout",
+        "flags.single.variant",
+        "flags.single.property",
+        "flags.single.regex",
+        "flags.single.cohort",
+        "flags.single.early",
+        "flags.single.late",
+        "flags.single.no-match"
+      ]
+    },
+    {
+      "id": "flags-scaling",
+      "workloads": ["flags.all.10", "flags.all.100", "flags.all.1000"]
+    },
+    {
+      "id": "flags-memory",
+      "workloads": ["flags.load.1000", "flags.refresh.1000"]
+    },
+    {
+      "id": "capture",
+      "workloads": [
+        "capture.enqueue.32",
+        "capture.enqueue.4096",
+        "capture.drain.steady.32",
+        "capture.drain.steady.4096",
+        "capture.drain.burst.32",
+        "capture.drain.burst.4096"
+      ]
+    }
+  ]
+}
diff --git a/benchmarks/test_benchmarks.py b/benchmarks/test_benchmarks.py
index b5dd19983..af51f4115 100644
--- a/benchmarks/test_benchmarks.py
+++ b/benchmarks/test_benchmarks.py
@@ -1,4 +1,6 @@
+import copy
 import gc
+import io
 import json
 import subprocess
 import sys
@@ -22,8 +24,9 @@
     time_operations,
 )
 from prepare import prepare
-from run import append_sample, main, run_worker
+from run import append_sample, load_shards, main, run_worker
 from server import BenchmarkServer
+from worker import execute
 from workload import Workload, control
 
 from posthog import Posthog
@@ -33,6 +36,449 @@
 
 
 class BenchmarksTest(unittest.TestCase):
+    def test_specification_inventory_and_parameters(self):
+        single_cases = (
+            "boolean",
+            "rollout",
+            "variant",
+            "property",
+            "regex",
+            "cohort",
+            "early",
+            "late",
+            "no-match",
+        )
+        for smoke in (False, True):
+            expected = {
+                **{
+                    f"flags.single.{case}": (
+                        160 if smoke else 16000,
+                        ["timing", "allocation"],
+                    )
+                    for case in single_cases
+                },
+                **{
+                    f"flags.all.{count}": (
+                        16 if smoke else operations,
+                        ["timing", "allocation"],
+                    )
+                    for count, operations in ((10, 1600), (100, 160), (1000, 160))
+                },
+                "flags.load.1000": (32 if smoke else 1600, ["memory"]),
+                "flags.refresh.1000": (4 if smoke else 40, ["memory"]),
+                **{
+                    f"capture.enqueue.{size}": (200 if smoke else 1000, ["timing"])
+                    for size in (32, 4096)
+                },
+                **{
+                    f"capture.drain.{strategy}.{size}": (
+                        200 if smoke else 1000,
+                        ["timing", "allocation", "memory"],
+                    )
+                    for strategy in ("steady", "burst")
+                    for size in (32, 4096)
+                },
+            }
+            specs = workloads(smoke)
+            self.assertEqual(len(specs), 20)
+            self.assertEqual(
+                {s["id"]: (s["operations"], s["passes"]) for s in specs}, expected
+            )
+            for spec in specs:
+                self.assertEqual(
+                    spec["concurrency"], 8 if spec["id"] == "flags.load.1000" else 1
+                )
+                if spec["mode"] == "single":
+                    self.assertEqual(spec["flag_count"], 10)
+                    self.assertEqual(
+                        spec["flag_index"],
+                        single_cases.index(spec["id"].split(".")[-1]),
+                    )
+                    self.assertEqual(
+                        spec["allocation_operations"], 160 if smoke else 2000
+                    )
+                elif "flag_count" in spec:
+                    self.assertEqual(spec["flag_count"], int(spec["id"].split(".")[-1]))
+                    if "allocation_operations" in spec:
+                        self.assertEqual(
+                            spec["allocation_operations"],
+                            16 if smoke else max(16, 1600 // spec["flag_count"]),
+                        )
+                else:
+                    self.assertEqual(
+                        spec["payload_bytes"], int(spec["id"].split(".")[-1])
+                    )
+                    self.assertEqual(
+                        spec["completion_boundary"],
+                        "api_return"
+                        if spec["mode"] == "capture"
+                        else "completed_delivery",
+                    )
+                    if spec["mode"] == "drain":
+                        self.assertEqual(
+                            spec["drain_strategy"], spec["id"].split(".")[2]
+                        )
+                        self.assertEqual(
+                            spec["flush_every"],
+                            100
+                            if spec["drain_strategy"] == "steady"
+                            else spec["operations"],
+                        )
+
+    def test_shard_manifest_exactly_partitions_full_and_smoke(self):
+        shards = load_shards()
+        self.assertEqual(
+            list(shards), ["flags-single", "flags-scaling", "flags-memory", "capture"]
+        )
+        assigned = [item for items in shards.values() for item in items]
+        for smoke in (False, True):
+            self.assertEqual(assigned, [spec["id"] for spec in workloads(smoke)])
+        self.assertEqual([len(items) for items in shards.values()], [9, 3, 2, 6])
+        with (
+            patch("run.workloads", side_effect=[workloads(), workloads(True)[:-1]]),
+            self.assertRaisesRegex(ValueError, "partition"),
+        ):
+            load_shards()
+
+    def test_shard_manifest_rejects_invalid_partitions_and_identifiers(self):
+        original = json.loads((ROOT / "benchmarks/shards.json").read_text())
+        for case in (
+            "version",
+            "sdk",
+            "empty",
+            "duplicate-shard",
+            "unsafe-id",
+            "empty-workloads",
+            "duplicate-within",
+            "duplicate-across",
+            "missing",
+            "unknown",
+            "extra-field",
+            "invalid-workload",
+        ):
+            manifest = copy.deepcopy(original)
+            shards = manifest["shards"]
+            if case == "version":
+                manifest["manifest_version"] = True
+            elif case == "sdk":
+                manifest["sdk"] = "posthog-node"
+            elif case == "empty":
+                manifest["shards"] = []
+            elif case == "duplicate-shard":
+                shards[1]["id"] = shards[0]["id"]
+            elif case == "unsafe-id":
+                shards[0]["id"] = "../flags-single"
+            elif case == "empty-workloads":
+                shards[0]["workloads"] = []
+            elif case == "duplicate-within":
+                shards[0]["workloads"].append(shards[0]["workloads"][0])
+            elif case == "duplicate-across":
+                shards[1]["workloads"].append(shards[0]["workloads"][0])
+            elif case == "missing":
+                shards[0]["workloads"].pop()
+            elif case == "unknown":
+                shards[0]["workloads"][0] = "flags.unknown"
+            elif case == "extra-field":
+                manifest["extra"] = 1
+            elif case == "invalid-workload":
+                shards[0]["workloads"][0] = []
+            with self.subTest(case=case), tempfile.TemporaryDirectory() as directory:
+                path = Path(directory) / "shards.json"
+                path.write_text(json.dumps(manifest))
+                with self.assertRaises(ValueError):
+                    load_shards(path)
+
+    def test_shard_and_filter_cli_errors_precede_execution(self):
+        for selection in (
+            ["--shard", "unknown"],
+            ["--shard", "capture", "--filter", "capture."],
+            ["--shard", "capture", "--filter", ""],
+            ["--filter", "unknown"],
+        ):
+            with (
+                self.subTest(selection=selection),
+                patch("run.document_for") as describe,
+                patch("sys.stderr", new_callable=io.StringIO),
+                self.assertRaises(SystemExit) as error,
+            ):
+                main(
+                    [
+                        "--base",
+                        str(ROOT),
+                        "--head",
+                        str(ROOT),
+                        "--output",
+                        "/unused",
+                        *selection,
+                    ]
+                )
+            self.assertEqual(error.exception.code, 2)
+            describe.assert_not_called()
+
+    def test_shards_preserve_suite_and_complete_alternating_repetitions(self):
+        suites = []
+        pair_ids = []
+        for shard_id, selected in load_shards().items():
+            with (
+                self.subTest(shard=shard_id),
+                tempfile.TemporaryDirectory() as directory,
+                patch("run.run_worker", return_value={"status": "ok"}) as worker,
+                patch("run.append_sample") as append,
+                patch("sys.stderr", new_callable=io.StringIO),
+            ):
+                self.assertEqual(
+                    main(
+                        [
+                            "--base",
+                            str(ROOT),
+                            "--head",
+                            str(ROOT),
+                            "--output",
+                            directory,
+                            "--smoke",
+                            "--shard",
+                            shard_id,
+                        ]
+                    ),
+                    0,
+                )
+                base = json.loads((Path(directory) / "base.json").read_text())
+                head = json.loads((Path(directory) / "head.json").read_text())
+                self.assertEqual(base["suite"], head["suite"])
+                suites.append(head["suite"])
+                self.assertEqual(head["suite"]["repetitions"], 6)
+                self.assertEqual(
+                    base["execution"]["pair_id"], head["execution"]["pair_id"]
+                )
+                pair_ids.append(head["execution"]["pair_id"])
+                for document in (base, head):
+                    self.assertEqual(document["execution"]["shard_id"], shard_id)
+                    self.assertEqual(
+                        [b["id"] for b in document["benchmarks"]], selected
+                    )
+                specs = [spec for spec in workloads(True) if spec["id"] in selected]
+                self.assertEqual(
+                    [(call.args[1], call.args[2]) for call in worker.call_args_list],
+                    [
+                        (spec, measurement_pass)
+                        for spec in specs
+                        for _ in range(6)
+                        for measurement_pass in spec["passes"]
+                        for _ in range(2)
+                    ],
+                )
+                expected = [
+                    (spec["id"], repetition, role)
+                    for spec in specs
+                    for repetition in range(6)
+                    for _ in spec["passes"]
+                    for role in (
+                        ["head", "base"] if repetition % 2 else ["base", "head"]
+                    )
+                ]
+                # Record identity distinguishes the two sides even for same-revision runs.
+                records = {
+                    id(call.args[0]): call.args[0] for call in append.call_args_list
+                }
+                roles: dict[int, str] = {}
+                for spec in specs:
+                    matching = [
+                        key
+                        for key, record in records.items()
+                        if record["id"] == spec["id"]
+                    ]
+                    roles.update(zip(matching, ("base", "head")))
+                self.assertEqual(
+                    [
+                        (call.args[0]["id"], call.args[2], roles[id(call.args[0])])
+                        for call in append.call_args_list
+                    ],
+                    expected,
+                )
+        self.assertTrue(all(suite == suites[0] for suite in suites))
+        self.assertEqual(len(set(pair_ids)), 4)
+
+    def test_capture_phase_reset_flush_schedules_and_fixture_ownership(self):
+        for strategy in ("steady", "burst"):
+            calls: list[int] = []
+            submitted: list[dict[str, Any]] = []
+
+            class Observed(Posthog):
+                def capture(self, event, _submitted=submitted, **kwargs):
+                    _submitted.append(kwargs["properties"])
+                    return super().capture(event, **kwargs)
+
+                def flush(self, timeout_seconds=10, _calls=calls, _submitted=submitted):
+                    _calls.append(len(_submitted))
+                    return super().flush(timeout_seconds=timeout_seconds)
+
+            spec = next(
+                s for s in workloads(True) if s["id"] == f"capture.drain.{strategy}.32"
+            )
+            with self.subTest(strategy=strategy), BenchmarkServer(spec) as server:
+                workload = Workload(spec, server.url, client_class=Observed)
+                try:
+                    workload.prepare_phase(160)
+                    workload.run(160)
+                    workload.verify()
+                    old_properties = list(submitted)
+                    workload.prepare_phase(spec["operations"])
+                    self.assertEqual(workload.state()["delivered"], 0)
+                    calls.clear()
+                    submitted.clear()
+                    checkpoints: list[tuple[int, list[int]]] = []
+                    with patch(
+                        "gc.collect",
+                        side_effect=AssertionError("GC inside measured work"),
+                    ):
+                        workload.run(
+                            checkpoint=lambda n, points=checkpoints, flushes=calls: (
+                                points.append((n, list(flushes)))
+                            )
+                        )
+                    self.assertEqual(
+                        calls, [100, 200] if strategy == "steady" else [200]
+                    )
+                    self.assertEqual(
+                        checkpoints,
+                        [(100, [100]), (200, [100, 200])]
+                        if strategy == "steady"
+                        else [(100, []), (200, [])],
+                    )
+                    count = len(calls)
+                    state = workload.verify()
+                    self.assertEqual(len(calls), count)
+                    self.assertEqual(state["unique_sequences"], 200)
+                    self.assertEqual(state["missing_sequences"], 0)
+                    self.assertEqual(
+                        [p["sequence"] for p in submitted], list(range(200))
+                    )
+                    self.assertEqual(
+                        len({id(p) for p in submitted + old_properties}), 360
+                    )
+                    self.assertEqual(
+                        [p["sequence"] for p in old_properties], list(range(160))
+                    )
+                finally:
+                    workload.close()
+
+    def test_balanced_duplicate_loss_fails_and_delivery_order_is_not_required(self):
+        spec = next(s for s in workloads(True) if s["id"] == "capture.drain.burst.32")
+        for duplicate in (False, True):
+            with self.subTest(duplicate=duplicate), BenchmarkServer(spec) as server:
+                workload = Workload(spec, server.url)
+                try:
+                    events = workload.events
+                    if duplicate:
+                        # Replace the final 16 events with the preceding 16: total and
+                        # per-identity counts stay identical, but sequences do not.
+                        events = events[:-16] + events[-32:-16]
+                    control(server.url, "/batch", {"batch": list(reversed(events))})
+                    workload.captured = spec["operations"]
+                    for event in workload.events:
+                        workload.captured_by_user[event["distinct_id"]] += 1
+                    self.assertEqual(
+                        workload.state()["delivered_by_user"], workload.captured_by_user
+                    )
+                    if duplicate:
+                        with self.assertRaises(AssertionError):
+                            workload.verify()
+                        self.assertEqual(workload.state()["missing_sequences"], 16)
+                    else:
+                        workload.verify()
+                finally:
+                    workload.close()
+
+    def test_incomplete_delivery_is_not_rescued_by_verification(self):
+        calls = []
+
+        class Incomplete(Posthog):
+            def flush(self, timeout_seconds=10):
+                calls.append(timeout_seconds)
+
+        spec = next(s for s in workloads(True) if s["id"] == "capture.drain.burst.32")
+        with BenchmarkServer(spec) as server:
+            workload = Workload(spec, server.url, client_class=Incomplete)
+            try:
+                workload.run()
+                with self.assertRaises(AssertionError):
+                    workload.verify()
+                self.assertEqual(calls, [None])
+            finally:
+                Posthog.flush(workload.client, timeout_seconds=None)
+                workload.close()
+
+    def test_refresh_generation_reset_and_full_sweeps_outside_measurement(self):
+        spec = next(s for s in workloads(True) if s["mode"] == "refresh")
+        with BenchmarkServer(spec) as server:
+            workload = Workload(spec, server.url)
+            try:
+                workload.run(2)
+                workload.verify()
+                workload.prepare_phase(spec["operations"])
+                self.assertEqual(workload.generation, 0)
+                for generation in range(1, 5):
+                    workload.run(1)
+                    self.assertEqual(workload.generation, generation)
+                    workload.verify()
+                workload.prepare_phase(spec["operations"])
+                checks = workload.checks
+                checkpoints: list[int] = []
+                with patch(
+                    "gc.collect", side_effect=AssertionError("GC inside measured work")
+                ):
+                    workload.run(checkpoint=checkpoints.append)
+                self.assertEqual(workload.checks, checks)
+                self.assertEqual(checkpoints, [1, 2, 3, 4])
+                workload.verify()
+                self.assertEqual(workload.checks, checks + 16)
+            finally:
+                workload.close()
+
+    def test_memory_checkpoint_positions_and_settling_order(self):
+        for workload_id, operations, positions in (
+            ("flags.load.1000", 70, [32, 64, 70]),
+            ("flags.refresh.1000", 4, [1, 2, 3, 4]),
+            ("capture.drain.steady.32", 250, [100, 200, 250]),
+            ("capture.drain.burst.32", 250, [100, 200, 250]),
+        ):
+            spec = {
+                **next(s for s in workloads(True) if s["id"] == workload_id),
+                "operations": operations,
+                "pass": "memory",
+            }
+            events: list[str] = []
+
+            class Observed(Workload):
+                def run(self, *args, _events=events, **kwargs):
+                    _events.append("run")
+                    with patch(
+                        "gc.collect",
+                        side_effect=AssertionError("GC inside measured work"),
+                    ):
+                        return super().run(*args, **kwargs)
+
+                def verify(self, _events=events):
+                    _events.append("verify")
+                    return super().verify()
+
+            with (
+                self.subTest(workload=workload_id),
+                BenchmarkServer(spec) as server,
+                patch("worker.Workload", Observed),
+                patch(
+                    "worker.settle", side_effect=lambda log=events: log.append("settle")
+                ),
+                patch(
+                    "worker.memory",
+                    side_effect=lambda log=events: log.append("memory") or memory(),
+                ),
+            ):
+                raw = execute(spec, server.url)
+            self.assertEqual([p["operations"] for p in raw["checkpoints"]], positions)
+            self.assertEqual(events[-4:], ["memory", "settle", "memory", "verify"])
+            self.assertEqual(events.count("settle"), 2)
+
     def test_deterministic_and_changing_fixtures(self):
         self.assertEqual(digest(definitions(1000)), digest(definitions(1000)))
         self.assertNotEqual(digest(definitions(1000)), digest(definitions(1000, 1)))
@@ -102,7 +548,7 @@ def flush(self, timeout_seconds=10):
                 )
 
         spec = {
-            **next(s for s in workloads(True) if s["id"] == "capture.drain.32"),
+            **next(s for s in workloads(True) if s["id"] == "capture.drain.steady.32"),
             "operations": 100,
         }
         with BenchmarkServer(spec, batch_delay=0.05) as server:
@@ -211,7 +657,6 @@ def load_feature_flags(self):
                 checkpoints = []
 
                 def checkpoint(completed):
-                    settle()
                     checkpoints.append((completed, memory()["rss"]))
 
                 workload.run(checkpoint=checkpoint)
@@ -295,32 +740,52 @@ def test_killed_worker_temporary_files_are_removed_by_the_coordinator(self):
             self.assertTrue(profile.parent.name.startswith("posthog-benchmark-worker-"))
             self.assertFalse(profile.parent.exists())
 
-    def test_repeated_timeouts_stop_the_suite_with_partial_results(self):
-        with (
-            tempfile.TemporaryDirectory() as directory,
-            patch(
-                "run.run_worker", return_value={"status": "timeout", "pass": "timing"}
-            ) as worker,
-        ):
-            code = main(
-                [
-                    "--base",
-                    str(ROOT),
-                    "--head",
-                    str(ROOT),
-                    "--output",
-                    directory,
-                    "--smoke",
-                ]
-            )
-            self.assertEqual(code, 1)
-            self.assertEqual(worker.call_count, 2)
-            for role in ("base", "head"):
-                document = json.loads((Path(directory) / f"{role}.json").read_text())
-                self.assertEqual(len(document["benchmarks"]), 1)
-                self.assertEqual(document["benchmarks"][0]["status"], "timeout")
-                self.assertEqual(document["benchmarks"][0]["metrics"], [])
-                self.assertEqual(len(document["benchmarks"][0]["runs"]), 1)
+    def test_repeated_timeouts_preserve_the_complete_inventory(self):
+        for shard in (None, *load_shards()):
+            with (
+                self.subTest(shard=shard),
+                tempfile.TemporaryDirectory() as directory,
+                patch(
+                    "run.run_worker",
+                    side_effect=lambda python, spec, measurement_pass: {
+                        "status": "timeout",
+                        "pass": measurement_pass,
+                    },
+                ) as worker,
+            ):
+                code = main(
+                    [
+                        "--base",
+                        str(ROOT),
+                        "--head",
+                        str(ROOT),
+                        "--output",
+                        directory,
+                        "--smoke",
+                        *(["--shard", shard] if shard else []),
+                    ]
+                )
+                self.assertEqual(code, 1)
+                self.assertEqual(worker.call_count, 2)
+                expected = (
+                    load_shards()[shard]
+                    if shard
+                    else [spec["id"] for spec in workloads(True)]
+                )
+                for role in ("base", "head"):
+                    document = json.loads(
+                        (Path(directory) / f"{role}.json").read_text()
+                    )
+                    records = document["benchmarks"]
+                    self.assertEqual([record["id"] for record in records], expected)
+                    self.assertEqual(records[0]["status"], "timeout")
+                    self.assertEqual(records[0]["metrics"], [])
+                    self.assertEqual(len(records[0]["runs"]), 1)
+                    for record in records[1:]:
+                        self.assertEqual(record["status"], "error")
+                        self.assertIn("not run", record["reason"])
+                        self.assertEqual(record["metrics"], [])
+                        self.assertEqual(record["runs"], [])
 
     def test_oom_classification_requires_evidence(self):
         self.assertEqual(classify_exit(stderr="Killed"), "error")
@@ -336,6 +801,11 @@ def test_package_identity_and_source_fingerprints(self):
             before = source_digest(directory)
             path.write_text("VALUE = 2")
             self.assertNotEqual(source_digest(directory), before)
+            manifest = Path(directory) / "shards.json"
+            manifest.write_text('{"manifest_version": 1}')
+            before = source_digest(directory)
+            manifest.write_text('{"manifest_version": 2}')
+            self.assertNotEqual(source_digest(directory), before)
 
     def test_paired_documents(self):
         with tempfile.TemporaryDirectory() as directory:
@@ -367,6 +837,8 @@ def test_paired_documents(self):
                 base["benchmarks"][0]["fixture_digest"],
                 head["benchmarks"][0]["fixture_digest"],
             )
+            self.assertEqual(base["suite"]["version"], 2)
+            self.assertEqual(base["suite"]["specification"], "sdk-benchmarks/v1")
             self.assertEqual(base["revision"]["role"], "base")
             self.assertEqual(head["revision"]["role"], "head")
             for metric in head["benchmarks"][0]["metrics"]:
diff --git a/benchmarks/worker.py b/benchmarks/worker.py
index e8b80f235..eb3f762a1 100644
--- a/benchmarks/worker.py
+++ b/benchmarks/worker.py
@@ -30,14 +30,16 @@ def execute(spec, host):
             if spec["mode"] == "refresh"
             else min(spec["operations"], 32 if spec.get("flag_count") == 1000 else 160)
         )
-        workload.run(warmup)
-        workload.verify()
-        settle()
         operations = (
             spec.get("allocation_operations", spec["operations"])
             if spec["pass"] == "allocation"
             else spec["operations"]
         )
+        workload.prepare_phase(warmup)
+        workload.run(warmup)
+        workload.verify()
+        workload.prepare_phase(operations)
+        settle()
         result = {
             "pass": spec["pass"],
             "operations": operations,
@@ -61,12 +63,9 @@ def execute(spec, host):
 
             def checkpoint(completed):
                 nonlocal observed
-                observed = max(observed, memory()["rss"])
-                if spec["mode"] == "refresh" and (
-                    completed % 5 == 0 or completed == spec["operations"]
-                ):
-                    settle()
-                    result["checkpoints"].append({"operations": completed, **memory()})
+                snapshot = memory()
+                observed = max(observed, snapshot["rss"])
+                result["checkpoints"].append({"operations": completed, **snapshot})
 
             start = time.perf_counter_ns()
             workload.run(checkpoint=checkpoint)
diff --git a/benchmarks/workload.py b/benchmarks/workload.py
index 069824c77..570cde328 100644
--- a/benchmarks/workload.py
+++ b/benchmarks/workload.py
@@ -49,26 +49,41 @@ def __init__(self, spec, host, client_class=None):
             if spec["concurrency"] > 1
             else None
         )
-        self.events = [
-            {
-                "event": "benchmark",
-                "distinct_id": user["distinct_id"],
-                "properties": {
-                    "payload": "x" * spec.get("payload_bytes", 0),
-                    "plan": "pro",
-                },
-            }
-            for user in USERS
-        ]
         try:
             if self.flags:
                 self.check_flags()
                 assert self.state()["definitions"] > 0
-            self.verify()
+                self.verify()
+            else:
+                self.prepare_phase(spec["operations"])
         except BaseException:
             self.close()
             raise
 
+    def prepare_phase(self, operations):
+        """Reset only outside measurement, after the preceding phase is verified."""
+        if self.flags:
+            self.generation = 0
+            control(self.host, "/__benchmark/definitions", {"generation": 0})
+            self.client.load_feature_flags()
+            self.check_flags()
+        else:
+            control(self.host, "/__benchmark/reset", {"operations": operations})
+            self.captured = 0
+            self.captured_by_user = {user["distinct_id"]: 0 for user in USERS}
+            self.events = [
+                {
+                    "event": "benchmark",
+                    "distinct_id": USERS[i % len(USERS)]["distinct_id"],
+                    "properties": {
+                        "payload": "x" * self.spec["payload_bytes"],
+                        "plan": "pro",
+                        "sequence": i,
+                    },
+                }
+                for i in range(operations)
+            ]
+
     def state(self):
         return control(self.host, "/__benchmark/state")
 
@@ -115,22 +130,30 @@ def run(self, operations=None, checkpoint=None):
                 before = self.state()["definitions"]
                 self.client.load_feature_flags()
                 assert self.state()["definitions"] == before + 1
-                self.check_flags()
                 if checkpoint:
                     checkpoint(i + 1)
         elif mode in ("capture", "drain"):
             for i in range(operations):
-                event = self.events[i % len(self.events)]
+                event = self.events[i]
                 assert self.client.capture(**event) is not None, (
                     "Capture rejected an event"
                 )
                 self.captured += 1
                 self.captured_by_user[USERS[i % len(USERS)]["distinct_id"]] += 1
-                if (i + 1) % 100 == 0 or i + 1 == operations:
-                    if mode == "drain":
-                        self.client.flush(timeout_seconds=None)
-                    if checkpoint:
-                        checkpoint(i + 1)
+                completed = i + 1
+                if (
+                    mode == "drain"
+                    and self.spec["drain_strategy"] == "steady"
+                    and (
+                        completed % self.spec["flush_every"] == 0
+                        or completed == operations
+                    )
+                ):
+                    self.client.flush(timeout_seconds=None)
+                if checkpoint and (completed % 100 == 0 or completed == operations):
+                    checkpoint(completed)
+            if mode == "drain" and self.spec["drain_strategy"] == "burst":
+                self.client.flush(timeout_seconds=None)
         else:
             for start in range(0, operations, self.spec["concurrency"]):
                 if self.pool:
@@ -145,8 +168,9 @@ def run(self, operations=None, checkpoint=None):
                         future.result()
                 else:
                     self.evaluate(start)
-                if checkpoint and start % 32 == 0:
-                    checkpoint(min(start + self.spec["concurrency"], operations))
+                completed = min(start + self.spec["concurrency"], operations)
+                if checkpoint and (completed % 32 == 0 or completed == operations):
+                    checkpoint(completed)
 
     def verify(self):
         if self.flags:
@@ -159,7 +183,11 @@ def verify(self):
         assert state["delivered"] == self.captured, (
             "Delivered counts must match captures"
         )
-        assert state["invalid_events"] == 0, "Capture payload or identity changed"
+        assert state["invalid_events"] == 0, (
+            "Capture payload, identity or sequence changed"
+        )
+        assert state["unique_sequences"] == self.captured
+        assert state["missing_sequences"] == 0, "Missing capture sequences"
         assert state["delivered_by_user"] == self.captured_by_user, (
             "Capture identity distribution changed"
         )

From 7cd0d8a4a9cadafc92bc479c4ec209436476132c Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Thu, 5 Nov 2026 06:47:01 -0500
Subject: [PATCH 180/245] fix(ai): record the HTTP status of streaming
 google-genai errors (#1188)

capture_streaming_event read only status_code, so failed Gemini streams
(generate_content_stream, sync and async) were captured with
$ai_http_status 0. Use _get_http_status, as the non-streaming path does.

Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>
---
 .../gemini-streaming-error-http-status.md        |  5 +++++
 posthog/ai/utils.py                              |  4 +---
 posthog/test/ai/test_stream_midstream_error.py   | 16 ++++++++++++++++
 3 files changed, 22 insertions(+), 3 deletions(-)
 create mode 100644 .sampo/changesets/gemini-streaming-error-http-status.md

diff --git a/.sampo/changesets/gemini-streaming-error-http-status.md b/.sampo/changesets/gemini-streaming-error-http-status.md
new file mode 100644
index 000000000..c2254d74f
--- /dev/null
+++ b/.sampo/changesets/gemini-streaming-error-http-status.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Streaming Gemini calls that fail now record the HTTP status of the google-genai error (for example 429 or 503) in `$ai_http_status`. Before, `capture_streaming_event` read only `status_code`, so these events were captured with a status of 0.
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index 54c601a3d..779ea705e 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -1096,9 +1096,7 @@ def capture_streaming_event(
             event_data["privacy_mode"],
             finalize_ai_content(event_data["formatted_output"], ph_client),
         ),
-        "$ai_http_status": (
-            getattr(error, "status_code", 0) if error is not None else 200
-        ),
+        "$ai_http_status": (_get_http_status(error) if error is not None else 200),
         **({"$ai_input_tokens": input_tokens} if input_tokens is not None else {}),
         **({"$ai_output_tokens": output_tokens} if output_tokens is not None else {}),
         "$ai_latency": event_data["latency"],
diff --git a/posthog/test/ai/test_stream_midstream_error.py b/posthog/test/ai/test_stream_midstream_error.py
index 1fbc8278f..386573a85 100644
--- a/posthog/test/ai/test_stream_midstream_error.py
+++ b/posthog/test/ai/test_stream_midstream_error.py
@@ -267,3 +267,19 @@ async def stream():
     props = _props(mock_client)
     assert props["$ai_is_error"] is True
     assert props["$ai_http_status"] == 0
+
+
+@pytest.mark.parametrize(
+    ("cls_name", "code"), [("ClientError", 429), ("ServerError", 503)]
+)
+def test_capture_streaming_event_records_google_genai_error_status(
+    mock_client, cls_name, code
+):
+    errors = pytest.importorskip("google.genai.errors")
+    error = getattr(errors, cls_name)(
+        code, {"error": {"code": code, "message": "nope", "status": "ERROR"}}
+    )
+    capture_streaming_event(mock_client, _event_data(error=error))
+    props = _props(mock_client)
+    assert props["$ai_http_status"] == code
+    assert props["$ai_is_error"] is True

From ff18e0f414e7555266cbc875e97daba70a91ad5b Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 11:48:54 +0000
Subject: [PATCH 181/245] chore: Release v7.83.3 [skip ci]

---
 .sampo/changesets/gemini-streaming-error-http-status.md | 5 -----
 openfeature-provider/CHANGELOG.md                       | 6 ++++++
 openfeature-provider/pyproject.toml                     | 2 +-
 posthog/CHANGELOG.md                                    | 6 ++++++
 posthog/version.py                                      | 2 +-
 pyproject.toml                                          | 2 +-
 uv.lock                                                 | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/gemini-streaming-error-http-status.md

diff --git a/.sampo/changesets/gemini-streaming-error-http-status.md b/.sampo/changesets/gemini-streaming-error-http-status.md
deleted file mode 100644
index c2254d74f..000000000
--- a/.sampo/changesets/gemini-streaming-error-http-status.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Streaming Gemini calls that fail now record the HTTP status of the google-genai error (for example 429 or 503) in `$ai_http_status`. Before, `capture_streaming_event` read only `status_code`, so these events were captured with a status of 0.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index c2e9dac84..5f4baf347 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.144 — 2026-11-05
+
+### Patch changes
+
+- Updated dependencies: posthog@7.83.3
+
 ## 0.1.143 — 2026-11-04
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 5edc15535..557f2b63a 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.143"
+version = "0.1.144"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 730ce2105..c97e61fa6 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.83.3 — 2026-11-05
+
+### Patch changes
+
+- [7cd0d8a](https://github.com/posthog/posthog-python/commit/7cd0d8a4a9cadafc92bc479c4ec209436476132c) Streaming Gemini calls that fail now record the HTTP status of the google-genai error (for example 429 or 503) in `$ai_http_status`. Before, `capture_streaming_event` read only `status_code`, so these events were captured with a status of 0. — Thanks @pcbeingused333!
+
 ## 7.83.2 — 2026-11-04
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 085987217..f1b455dd8 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.83.2"
+VERSION = "7.83.3"
diff --git a/pyproject.toml b/pyproject.toml
index 83af0d71c..3dc2ac953 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.83.2"
+version = "7.83.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 67deb9c1c..359a9041f 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.143"
+version = "0.1.144"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.83.2"
+version = "7.83.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 8a40ae39839e8626754a2cf9f5f9d9830bd1fd6d Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 11:48:59 +0000
Subject: [PATCH 182/245] Update generated references

---
 .../posthog-python-references-7.83.3.json     | 3566 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3567 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.83.3.json

diff --git a/references/posthog-python-references-7.83.3.json b/references/posthog-python-references-7.83.3.json
new file mode 100644
index 000000000..b68caab6f
--- /dev/null
+++ b/references/posthog-python-references-7.83.3.json
@@ -0,0 +1,3566 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.83.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 8962f1f55..b68caab6f 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.83.2",
+    "version": "7.83.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From b741c65a5cd0e503aaf915e695cdb4d54686d9f9 Mon Sep 17 00:00:00 2001
From: Jae Birdsall <jaeminbird@gmail.com>
Date: Thu, 5 Nov 2026 07:00:29 -0500
Subject: [PATCH 183/245] fix(ai): don't subtract cache tokens twice for
 ChatAnthropic invoke (#1189)

fix(ai): stop subtracting cache tokens twice for non-streamed ChatAnthropic calls

ChatAnthropic.invoke copies the raw Anthropic usage into response_metadata,
and the callback handler read it before the standard usage_metadata. Its
input_tokens already exclude cache reads and writes, so the Anthropic cache
subtraction ran a second time and a cached call reported 0 input tokens.
Read usage_metadata first, as streamed calls already do.

The same check also covers Claude models served by other LangChain
providers (ChatAnthropicVertex), which report Anthropic-style usage
with cache tokens outside input_tokens.
---
 .../langchain-anthropic-cache-input-tokens.md |  5 ++
 posthog/ai/langchain/callbacks.py             | 16 ++--
 posthog/test/ai/langchain/test_callbacks.py   | 87 +++++++++++++++++++
 posthog/test/test_metrics_autocapture.py      |  7 +-
 4 files changed, 108 insertions(+), 7 deletions(-)
 create mode 100644 .sampo/changesets/langchain-anthropic-cache-input-tokens.md

diff --git a/.sampo/changesets/langchain-anthropic-cache-input-tokens.md b/.sampo/changesets/langchain-anthropic-cache-input-tokens.md
new file mode 100644
index 000000000..fd34d4c9b
--- /dev/null
+++ b/.sampo/changesets/langchain-anthropic-cache-input-tokens.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+The LangChain callback handler no longer reports too few input tokens for a non-streamed `ChatAnthropic` call that reads or writes the prompt cache. It took the raw Anthropic usage from `response_metadata`, whose input tokens already exclude the cache, and subtracted the cache tokens again, so a cached call usually reported 0 input tokens. It now reads LangChain's standard `usage_metadata` first, as it already did for streamed calls.
diff --git a/posthog/ai/langchain/callbacks.py b/posthog/ai/langchain/callbacks.py
index 757179aac..e94d843e8 100644
--- a/posthog/ai/langchain/callbacks.py
+++ b/posthog/ai/langchain/callbacks.py
@@ -969,11 +969,12 @@ def _parse_usage_model(
     # Both cache_read and cache_write tokens should be subtracted since Anthropic's raw API
     # reports input_tokens as tokens NOT read from or used to create a cache.
     # For other providers (OpenAI, etc.), input_tokens already excludes cache tokens as expected.
-    # Match logic consistent with plugin-server: exact match on provider OR substring match on model
+    # Match logic consistent with plugin-server: exact match on provider, substring
+    # match on model, or a Claude model under another provider (e.g. Vertex AI)
     is_anthropic = False
     if provider and provider.lower() == "anthropic":
         is_anthropic = True
-    elif model and "anthropic" in model.lower():
+    elif model and ("anthropic" in model.lower() or model.lower().startswith("claude")):
         is_anthropic = True
 
     if is_anthropic and normalized_usage.input_tokens:
@@ -1047,12 +1048,15 @@ def _parse_usage(
                     if isinstance(response_metadata, dict)
                     else None
                 )
-                ollama_usage = getattr(
-                    message_chunk, "usage_metadata", None
-                )  # for Ollama
+                # LangChain's standard usage, which also covers Ollama
+                usage_metadata = getattr(message_chunk, "usage_metadata", None)
 
+                # Prefer the standard usage: its input_tokens include cache reads
+                # and writes, as the Anthropic subtraction in _parse_usage_model
+                # expects. ChatAnthropic also copies the raw API usage, whose
+                # input_tokens already exclude the cache, into response_metadata.
                 chunk_usage = (
-                    bedrock_anthropic_usage or bedrock_titan_usage or ollama_usage
+                    usage_metadata or bedrock_anthropic_usage or bedrock_titan_usage
                 )
                 if chunk_usage:
                     llm_usage = _parse_usage_model(chunk_usage, provider, model)
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index 4b0057309..b4ae495e8 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -1724,6 +1724,93 @@ def test_anthropic_provider_subtracts_cache_tokens(mock_client):
     assert generation_args["properties"]["$ai_cache_read_input_tokens"] == 800
 
 
+def test_chat_anthropic_invoke_does_not_subtract_cache_tokens_twice(mock_client):
+    """ChatAnthropic.invoke puts the raw API usage, whose input_tokens already
+    exclude the cache, in response_metadata next to the standard usage_metadata."""
+    from langchain_core.outputs import LLMResult, ChatGeneration
+    from langchain_core.messages import AIMessage
+    from uuid import uuid4
+
+    cb = CallbackHandler(mock_client)
+    run_id = uuid4()
+    cb._set_llm_metadata(
+        serialized={},
+        run_id=run_id,
+        messages=[{"role": "user", "content": "test"}],
+        metadata={"ls_provider": "anthropic", "ls_model_name": "claude-sonnet-4-5"},
+    )
+
+    # The message ChatAnthropic.invoke returns for a cached prompt
+    message = AIMessage(
+        content="Response",
+        response_metadata={
+            "id": "msg_1",
+            "model": "claude-sonnet-4-5",
+            "stop_reason": "end_turn",
+            "usage": {
+                "input_tokens": 10,
+                "output_tokens": 7,
+                "cache_creation_input_tokens": 100,
+                "cache_read_input_tokens": 1000,
+            },
+            "model_provider": "anthropic",
+        },
+        usage_metadata={
+            "input_tokens": 1110,
+            "output_tokens": 7,
+            "total_tokens": 1117,
+            "input_token_details": {"cache_read": 1000, "cache_creation": 100},
+        },
+    )
+    response = LLMResult(generations=[[ChatGeneration(message=message)]])
+
+    cb._pop_run_and_capture_generation(run_id, None, response)
+
+    props = mock_client.capture.call_args_list[0][1]["properties"]
+    assert props["$ai_input_tokens"] == 10
+    assert props["$ai_output_tokens"] == 7
+    assert props["$ai_cache_read_input_tokens"] == 1000
+    assert props["$ai_cache_creation_input_tokens"] == 100
+
+
+def test_claude_on_vertex_subtracts_cache_tokens(mock_client):
+    """ChatAnthropicVertex reports provider "anthropicvertex" and a bare Claude
+    model name. Its usage_metadata input_tokens include the cache, like
+    ChatAnthropic's, and PostHog prices claude-* models Anthropic-style."""
+    from langchain_core.outputs import LLMResult, ChatGeneration
+    from langchain_core.messages import AIMessage
+    from uuid import uuid4
+
+    cb = CallbackHandler(mock_client)
+    run_id = uuid4()
+    cb._set_llm_metadata(
+        serialized={},
+        run_id=run_id,
+        messages=[{"role": "user", "content": "test"}],
+        metadata={
+            "ls_provider": "anthropicvertex",
+            "ls_model_name": "claude-sonnet-4-5@20250929",
+        },
+    )
+    message = AIMessage(
+        content="Response",
+        usage_metadata={
+            "input_tokens": 1110,
+            "output_tokens": 7,
+            "total_tokens": 1117,
+            "input_token_details": {"cache_read": 1000, "cache_creation": 100},
+        },
+    )
+    response = LLMResult(generations=[[ChatGeneration(message=message)]])
+
+    cb._pop_run_and_capture_generation(run_id, None, response)
+
+    props = mock_client.capture.call_args_list[0][1]["properties"]
+    assert props["$ai_input_tokens"] == 10
+    assert props["$ai_cache_read_input_tokens"] == 1000
+    assert props["$ai_cache_creation_input_tokens"] == 100
+
+
 def test_anthropic_provider_subtracts_cache_write_tokens(mock_client):
     """Test that Anthropic provider correctly subtracts cache write tokens from input tokens."""
     from langchain_core.outputs import LLMResult, ChatGeneration
diff --git a/posthog/test/test_metrics_autocapture.py b/posthog/test/test_metrics_autocapture.py
index e69310b49..57221289d 100644
--- a/posthog/test/test_metrics_autocapture.py
+++ b/posthog/test/test_metrics_autocapture.py
@@ -941,7 +941,12 @@ def test_does_not_propagate_context_to_other_services(
         for request in app_server.received:
             headers = {key.lower() for key in request["headers"]}
             assert not headers & {"traceparent", "tracestate", "baggage"}
-        assert len(_points(reader, "http.client.request.duration")) == 2
+        points = [
+            point
+            for point in _points(reader, "http.client.request.duration")
+            if point.attributes.get("server.port") == app_server.port
+        ]
+        assert len(points) == 2
 
         handle.shutdown()
         requests_instrumentation = sys.modules["opentelemetry.instrumentation.requests"]

From 063f1cece68ee0d6e4d644d4b6fe0fbe335e3b29 Mon Sep 17 00:00:00 2001
From: Michael Reichenbach <755327+Silthus@users.noreply.github.com>
Date: Thu, 5 Nov 2026 12:10:20 +0000
Subject: [PATCH 184/245] feat: send email content from code with
 posthog.emails.send (#1171)

* feat: send email content from code with posthog.emails.send

Squash of Silthus/posthog-python#2 at e5fdedf, re-signed for required signatures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: cut emails.send to the template and rendered code forms

Parks the local-template form (template_data on a code send, the
content hash, the upload by key and its retry) and the cc, bcc,
headers, tags and attachments fields, to match posthog-node. A code
send now takes rendered html and/or text only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(emails): cover the async code-form send and migrated_from

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): leave reply_to out when the list is empty

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(emails): name the transactional_email scopes for sends and status reads

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(emails): rewrite the release note for transactional email

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/scripts/check_strict_types.sh |  32 +-
 .sampo/changesets/emails-code-form.md |  28 ++
 posthog/async_client.py               |  13 +-
 posthog/client.py                     |  15 +-
 posthog/emails.py                     | 449 +++++++++++++++++++++-----
 posthog/test/test_emails.py           | 229 ++++++++++++-
 references/public_api_snapshot.txt    |  25 +-
 7 files changed, 684 insertions(+), 107 deletions(-)
 create mode 100644 .sampo/changesets/emails-code-form.md

diff --git a/.github/scripts/check_strict_types.sh b/.github/scripts/check_strict_types.sh
index 7b46c0af0..4e41c9e8f 100755
--- a/.github/scripts/check_strict_types.sh
+++ b/.github/scripts/check_strict_types.sh
@@ -15,6 +15,7 @@ import atexit
 
 import posthog
 from posthog import FeatureFlagEvaluations, FlagValue, Posthog
+from posthog.emails import AsyncEmails, Emails, SendEmailResult
 from posthog.ai.evaluations import (
     AsyncOfflineEvaluations,
     BooleanScorerConfig,
@@ -40,6 +41,16 @@ span.end()
 
 _ = (flag_value, all_flags, enabled, payload, evaluations, active)
 
+emails = Emails("phs_example")
+template_send: SendEmailResult = emails.send(to="user@example.com", template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b", template_data={"name": "Ada"})
+rendered_send: SendEmailResult = emails.send(to="user@example.com", template_key="password-reset", subject="Reset", html="<p>Reset</p>", from_="Acme <security@example.com>", reply_to=["help@example.com"], capture_engagement=False, max_retries=0)
+_ = (template_send, rendered_send)
+
+
+async def async_email_types() -> None:
+    sent: SendEmailResult = await AsyncEmails("phs_example").send(to="user@example.com", template_key="welcome", subject="Hi", html="<p>Hi</p>")
+    _ = sent
+
 
 async def offline_evaluation_types(
     sync_client: OfflineEvaluations, async_client: AsyncOfflineEvaluations
@@ -64,15 +75,26 @@ async def offline_evaluation_types(
     _ = config
 PY
 
-cat > "$tmp/invalid_offline_types.py" <<'PY'
+cat > "$tmp/invalid_types.py" <<'PY'
 # pyright: strict
 from posthog.ai.evaluations import BooleanScorerConfig, CategoricalScorerConfig, NumericPassingRule, NumericScorerConfig, OfflineEvaluations
+from posthog.emails import AsyncEmails, Emails
 
 client = OfflineEvaluations(project_id=123, secret_key="phx_example")
 NumericPassingRule(operator="gt", threshold=0.8)  # expected-type-error
 NumericScorerConfig(unknown_setting=True)  # expected-type-error
 CategoricalScorerConfig(selection_mode="single")  # expected-type-error
 client.scorers.create(name="Bad config", kind="numeric", config=BooleanScorerConfig(true_is_failure=True))  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b", template_key="welcome", subject="Hi", html="<p>Hi</p>")  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_key="welcome", html="<p>Hi</p>")  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b", cc="team@example.com")  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b", capture_engagement=False)  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_key="welcome", subject="Hi", html="<p>Hi</p>", template_data={"name": "Ada"})  # expected-type-error
+Emails("phs_example").send(to="user@example.com", template_key="welcome", subject="Hi", html="<p>Hi</p>", cc="team@example.com")  # expected-type-error
+
+
+async def invalid_async_email() -> None:
+    await AsyncEmails("phs_example").send(to="user@example.com", template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b", subject="Hi")  # expected-type-error
 PY
 
 "$tmp/.venv/bin/python" - <<'PY' > "$tmp/public_api_access.py"
@@ -116,8 +138,8 @@ JSON
 cd "$tmp"
 "$tmp/.venv/bin/python" -m pyright strict_posthog_types.py public_api_access.py
 
-if "$tmp/.venv/bin/python" -m pyright --outputjson invalid_offline_types.py > invalid_types.json; then
-    echo "Invalid offline evaluation configurations unexpectedly passed type checking."
+if "$tmp/.venv/bin/python" -m pyright --outputjson invalid_types.py > invalid_types.json; then
+    echo "Invalid offline evaluation configurations and email sends unexpectedly passed type checking."
     exit 1
 fi
 "$tmp/.venv/bin/python" - <<'PY'
@@ -125,11 +147,11 @@ import json
 from pathlib import Path
 
 expected = {
-    index for index, line in enumerate(Path("invalid_offline_types.py").read_text().splitlines())
+    index for index, line in enumerate(Path("invalid_types.py").read_text().splitlines())
     if "expected-type-error" in line
 }
 diagnostics = json.loads(Path("invalid_types.json").read_text())["generalDiagnostics"]
 actual = {item["range"]["start"]["line"] for item in diagnostics if item["severity"] == "error"}
 assert actual == expected, diagnostics
-print("Offline evaluation configuration types reject invalid inputs.")
+print("Offline evaluation configuration and email send types reject invalid inputs.")
 PY
diff --git a/.sampo/changesets/emails-code-form.md b/.sampo/changesets/emails-code-form.md
new file mode 100644
index 000000000..4264b2b9c
--- /dev/null
+++ b/.sampo/changesets/emails-code-form.md
@@ -0,0 +1,28 @@
+---
+pypi/posthog: minor
+---
+
+`posthog.emails.send()` can now send email content your code rendered, such as HTML from Jinja or React Email. Give the email a `template_key` and a `subject`, and pass `html`, `text` or both.
+
+```python
+posthog = Posthog("phc_...", secret_key="phs_...")
+
+result = posthog.emails.send(
+    to="user@example.com",
+    distinct_id="user_123",
+    template_key="password-reset",
+    subject="Reset your password",
+    html=rendered_html,
+)
+
+# "delivered", "bounced", ...
+status = posthog.emails.get(result.id).status
+```
+
+You need a project secret API key, the kind that starts with `phs_`. Create one under **Project secret API keys** in your project settings. Set its **Transactional email** scope to Write to send emails, or to Read for a key that only reads statuses. Pass it to the client as `secret_key`. Set `app_host` to your PostHog app URL when you self-host PostHog or send through a reverse proxy.
+
+PostHog records each email's delivery, opens and clicks on the person with that `distinct_id`. It groups every email with the same `template_key`, so you see their metrics and logs in one place. The SDK retries a request that hits a network error, a rate limit or an outage twice by default. Every send carries an idempotency key, so a retry never sends the email twice. Pass your own `idempotency_key`, such as `welcome:user_123`, and your job runner's retries are safe too.
+
+A send with your own content also takes `from_`, `reply_to` and `capture_engagement=False`. Set `migrated_from` on the client to tell PostHog which email provider you moved from. A failed call raises an `EmailError` with PostHog's `code` and the HTTP `status_code`.
+
+Docs: [Send transactional emails with Python](https://posthog.com/docs/workflows/transactional-emails/python) and the [transactional email overview](https://posthog.com/docs/workflows/transactional-emails).
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 72f7cd2fe..48de0abd6 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -137,6 +137,7 @@ def __init__(
         app_host: Optional[str] = None,
         email_request_timeout_seconds: float = 15,
         email_request_max_retries: int = 2,
+        migrated_from: Optional[str] = None,
     ) -> None:
         if flush_at <= 0:
             raise ValueError("flush_at must be greater than zero")
@@ -181,10 +182,13 @@ def __init__(
             else resolved_secret_key
         ) or None
         self.personal_api_key = self.secret_key
-        _validate_options(email_request_timeout_seconds, email_request_max_retries)
+        _validate_options(
+            email_request_timeout_seconds, email_request_max_retries, migrated_from
+        )
         self.app_host = app_host
         self.email_request_timeout_seconds = email_request_timeout_seconds
         self.email_request_max_retries = email_request_max_retries
+        self.migrated_from = migrated_from
         self.feature_flags_request_timeout_seconds = (
             feature_flags_request_timeout_seconds
         )
@@ -266,10 +270,10 @@ def __init__(
     @property
     def emails(self) -> AsyncEmails:
         """
-        Send transactional email from PostHog email templates, and read the
-        status of each email sent with ``get``.
+        Send transactional email from PostHog email templates or from content
+        in your code, and read the status of each email sent with ``get``.
 
-        Needs ``secret_key``, a project secret API key with the ``hog_flow:write``
+        Needs ``secret_key``, a project secret API key with the ``transactional_email:write``
         scope, and ``posthog[async]``. Sends go to ``app_host``, or to the PostHog
         Cloud app host of ``host``. ``email_request_timeout_seconds`` and
         ``email_request_max_retries`` configure each send. A disabled or shut-down
@@ -294,6 +298,7 @@ def emails(self) -> AsyncEmails:
                 app_host=self.app_host,
                 timeout=self.email_request_timeout_seconds,
                 max_retries=self.email_request_max_retries,
+                migrated_from=self.migrated_from,
             )
         return self._emails
 
diff --git a/posthog/client.py b/posthog/client.py
index ce5eb3352..87ba50705 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -737,6 +737,7 @@ def __init__(
         app_host: Optional[str] = None,
         email_request_timeout_seconds: float = 15,
         email_request_max_retries: int = 2,
+        migrated_from: Optional[str] = None,
     ):
         """
         Initialize a new PostHog client instance.
@@ -797,6 +798,8 @@ def __init__(
             email_request_max_retries: Number of retries for an email send after a
                 network error, a rate limit, or an unavailable service. Defaults to 2.
                 Set to 0 when a job runner already retries the send.
+            migrated_from: The email provider you moved from, such as
+                ``"resend"``. ``emails`` sends it with every request.
             super_properties: Properties merged into every captured event.
             enable_exception_autocapture: Automatically capture uncaught
                 exceptions.
@@ -1074,10 +1077,13 @@ def __init__(
             else resolved_secret_key
         ) or None
         self.personal_api_key = self.secret_key
-        _validate_options(email_request_timeout_seconds, email_request_max_retries)
+        _validate_options(
+            email_request_timeout_seconds, email_request_max_retries, migrated_from
+        )
         self.app_host = app_host
         self.email_request_timeout_seconds = email_request_timeout_seconds
         self.email_request_max_retries = email_request_max_retries
+        self.migrated_from = migrated_from
         if debug:
             # Ensures that debug level messages are logged when debug mode is on.
             # Otherwise, defaults to WARNING level. See https://docs.python.org/3/howto/logging.html#what-happens-if-no-configuration-is-provided
@@ -1256,10 +1262,10 @@ def _request_identity_kwargs(self) -> Dict[str, str]:
     @property
     def emails(self) -> Emails:
         """
-        Send transactional email from PostHog email templates, and read the
-        status of each email sent with ``get``.
+        Send transactional email from PostHog email templates or from content
+        in your code, and read the status of each email sent with ``get``.
 
-        Needs ``secret_key``, a project secret API key with the ``hog_flow:write``
+        Needs ``secret_key``, a project secret API key with the ``transactional_email:write``
         scope. Sends go to ``app_host``, or to the PostHog Cloud app host of
         ``host``. ``email_request_timeout_seconds`` and ``email_request_max_retries``
         configure each send. A disabled or shut-down client sends nothing. See
@@ -1285,6 +1291,7 @@ def emails(self) -> Emails:
                 app_host=self.app_host,
                 timeout=self.email_request_timeout_seconds,
                 max_retries=self.email_request_max_retries,
+                migrated_from=self.migrated_from,
             )
         return self._emails
 
diff --git a/posthog/emails.py b/posthog/emails.py
index c5bb6cec8..c53528c7c 100644
--- a/posthog/emails.py
+++ b/posthog/emails.py
@@ -1,11 +1,13 @@
-"""Transactional email, sent from an email template in PostHog.
+"""Transactional email, sent from an email template in PostHog or from content in your code.
 
 Setup:
 
 1. In PostHog, open the email template under Workflows, make it transactional,
    and copy its ID. ``template_id`` is that UUID.
-2. Create a project secret API key (``phs_...``) with Workflow write access
-   (``hog_flow:write``) in your project settings. The project API key
+2. Create a project secret API key (``phs_...``) with the "Send transactional
+   email" preset (``transactional_email:write``) in your project settings. Add
+   ``transactional_email:read`` too if you read email statuses with a key that
+   can't send. Keys made with ``hog_flow:write`` still work. The project API key
    (``phc_...``) captures events but cannot send email.
 3. Send from the client you already use, or from :class:`Emails` in a process
    that only sends email:
@@ -22,6 +24,15 @@
     idempotency_key="welcome:user_123",
 )
 print(result.id)  # the queued email
+
+# Content you rendered for this recipient, named by a key
+posthog.emails.send(
+    to="user@example.com",
+    template_key="password-reset",
+    subject="Reset your password",
+    html=rendered_html,
+    distinct_id="user_123",
+)
 ```
 
 ``posthog.emails`` above is the client's property. For async code, use
@@ -44,13 +55,17 @@
 :class:`Emails`, when a job runner already retries the send, and pass an
 ``idempotency_key`` that names the email, such as ``welcome:user_123``.
 
+Moving from another email provider: set ``migrated_from``, such as
+``"resend"``, on the client or on :class:`Emails`, so PostHog knows where your
+sends came from.
+
 Errors: a send that is not queued raises :class:`EmailError`. Branch on
 ``code``. The ones a setup usually hits:
 
 - ``missing_secret_key``: the client has no ``secret_key``.
 - ``missing_app_host``: the client's ``host`` is not PostHog Cloud. Set ``app_host``.
 - ``authentication_failed`` (401) or ``permission_denied`` (403): the key is
-  wrong, or it lacks ``hog_flow:write``.
+  wrong, or it lacks ``transactional_email:write``.
 - ``not_found`` (404): the template ID is wrong, or transactional email is not
   enabled for the project.
 - ``client_disabled``: the client is disabled, so it sends nothing.
@@ -58,9 +73,9 @@
 
 Status: ``emails.get(message_id)`` reads what happened to a sent email, for
 30 days after the send, as an :class:`EmailStatus`. A key with only
-``hog_flow:read`` can read statuses but not send. ``get`` raises ``not_found``
-(404) for an unknown ID, an email older than 30 days, or for a few seconds
-after the send.
+``transactional_email:read`` can read statuses but not send. ``get`` raises
+``not_found`` (404) for an unknown ID, an email older than 30 days, or for a
+few seconds after the send.
 
 Cleanup: ``shutdown()`` on the client closes its email connections. Close a
 standalone :class:`Emails` with ``close()`` or a ``with`` block.
@@ -85,10 +100,21 @@
 from dataclasses import dataclass
 from datetime import datetime
 from types import TracebackType
-from typing import Any, Callable, Mapping, Optional, TypeVar, Union
+from typing import (
+    Any,
+    Callable,
+    Mapping,
+    Optional,
+    Sequence,
+    TypedDict,
+    TypeVar,
+    Union,
+    overload,
+)
 from uuid import UUID, uuid4
 
 import requests
+from typing_extensions import NotRequired, Unpack
 
 from .capture_v1 import _parse_retry_after
 from .request import (
@@ -102,19 +128,23 @@
 
 __all__ = [
     "AsyncEmails",
+    "CodeEmailArgs",
     "EmailError",
     "EmailStatus",
     "EmailWarning",
     "Emails",
     "SendEmailResult",
+    "TemplateEmailArgs",
 ]
 
 log = logging.getLogger("posthog")
 
 _SEND_PATH = "/api/projects/@current/messaging/send/email/"
 _STATUS_PATH = "/api/projects/@current/messaging/emails/{message_id}/"
+_TEMPLATE_KEY = re.compile(r"[a-zA-Z0-9_-]{1,400}")
 _MAX_RETRY_DELAY = 30.0
 _IDEMPOTENCY_KEY = re.compile(r"^[\x21-\x7e]{1,255}$")
+_HEADER_TOKEN = re.compile(r"[\x21-\x7e]+")
 _IN_FLIGHT_CODES = frozenset({"idempotency_key_in_flight"})
 _QUOTA_CODES = frozenset({"quota_limited"})
 
@@ -168,6 +198,85 @@ class SendEmailResult:
     warnings: tuple[EmailWarning, ...] = ()
 
 
+class _RecipientArgs(TypedDict):
+    to: str
+    distinct_id: NotRequired[Optional[str]]
+    idempotency_key: NotRequired[Optional[str]]
+    max_retries: NotRequired[Optional[int]]
+
+
+class TemplateEmailArgs(_RecipientArgs):
+    """A send of an email template made in PostHog, named by its ID.
+
+    Args:
+        to: One recipient email address.
+        template_id: The UUID of a template made transactional in PostHog.
+        template_data: Values for the template's ``{{ variables.* }}``
+            placeholders.
+        distinct_id: The recipient's distinct ID in your product.
+        idempotency_key: 1 to 255 visible ASCII characters.
+        max_retries: Overrides the client's maximum number of retries for this
+            send. ``0`` turns retries off.
+    """
+
+    template_id: Union[str, UUID]
+    template_data: NotRequired[Optional[Mapping[str, Any]]]
+
+
+class CodeEmailArgs(_RecipientArgs):
+    """A send of email content that your code rendered for one recipient, named by a key.
+
+    The content goes out as is. To send a React email, render it to HTML in
+    your app first.
+
+    An optional field passed as ``None`` counts as left out.
+
+    Args:
+        to: One recipient email address.
+        template_key: Names the email, so its metrics, logs and status group
+            under it. Letters, digits, ``-`` and ``_``, at most 400.
+        subject: The subject line.
+        html: The HTML body. Give ``html``, ``text`` or both.
+        text: The plain-text body. Without it, PostHog derives it from
+            ``html``. HTML with no text in it, such as a single image, goes out
+            without a plain-text part.
+        from_: A verified sender, such as ``"Acme <hello@example.com>"``.
+        reply_to: One address or a list of addresses. An empty list sends no reply-to.
+        capture_engagement: Capture the email's opens and clicks as events of
+            the recipient. Defaults to ``True``. A project whose admin turned
+            engagement capture off captures nothing, whatever the send asks. A
+            template made in PostHog follows the project's setting, so the
+            template form doesn't take it.
+        distinct_id: The recipient's distinct ID in your product.
+        idempotency_key: 1 to 255 visible ASCII characters. Template sends
+            and code sends share one set of keys: a key already used for
+            another email, or for a ``template_id`` send, raises
+            ``idempotency_key_reused``. A retry with the same key returns the
+            first send's result, also when its workflow was paused since.
+        max_retries: Overrides the client's maximum number of retries for this
+            send. ``0`` turns retries off.
+    """
+
+    template_key: str
+    subject: str
+    html: NotRequired[Optional[str]]
+    text: NotRequired[Optional[str]]
+    from_: NotRequired[Optional[str]]
+    reply_to: NotRequired[Optional[Union[str, Sequence[str]]]]
+    capture_engagement: NotRequired[Optional[bool]]
+
+
+_OPTIONAL_CODE_FIELDS = frozenset(
+    {
+        "html",
+        "text",
+        "from_",
+        "reply_to",
+        "capture_engagement",
+    }
+)
+
+
 @dataclass(frozen=True)
 class EmailStatus:
     """What happened to an email that ``send()`` queued.
@@ -202,6 +311,114 @@ class _PreparedSend:
     max_retries: Optional[int] = None
 
 
+def _prepare(args: Mapping[str, Any]) -> _PreparedSend:
+    is_template_form = "template_id" in args
+    if is_template_form == ("template_key" in args):
+        raise TypeError("Pass either template_id or template_key.")
+    form = TemplateEmailArgs if is_template_form else CodeEmailArgs
+    unexpected = sorted(set(args) - set(form.__annotations__))
+    if unexpected:
+        raise TypeError(
+            f"send() got arguments that the {'template' if is_template_form else 'code'} "
+            f"form doesn't take: {', '.join(unexpected)}."
+        )
+    if "to" not in args:
+        raise TypeError("send() is missing the argument to.")
+    if is_template_form:
+        return _prepare_send(
+            args["to"],
+            args["template_id"],
+            args.get("template_data"),
+            args.get("distinct_id"),
+            args.get("idempotency_key"),
+            args.get("max_retries"),
+        )
+    return _prepare_code_send(args)
+
+
+def _prepare_code_send(args: Mapping[str, Any]) -> _PreparedSend:
+    args = {
+        name: value
+        for name, value in args.items()
+        if value is not None or name not in _OPTIONAL_CODE_FIELDS
+    }
+    if "subject" not in args:
+        raise TypeError("send() is missing the argument subject.")
+    to, distinct_id, idempotency_key = _recipient(
+        args["to"], args.get("distinct_id"), args.get("idempotency_key")
+    )
+    max_retries = _retry_limit(args.get("max_retries"))
+    template_key = args["template_key"]
+    if not isinstance(template_key, str) or not _TEMPLATE_KEY.fullmatch(template_key):
+        raise ValueError(
+            "template_key can only have letters, digits, hyphens (-) and underscores (_), at most 400."
+        )
+    content = {"subject": _nonempty_text(args, "subject")}
+    content.update(
+        {field: _string(args, field) for field in ("html", "text") if field in args}
+    )
+    if "html" not in content and "text" not in content:
+        raise TypeError("send() needs html, text or both.")
+    if not (content.get("html") or content.get("text")):
+        raise ValueError("html or text must be a nonempty string.")
+
+    payload: dict[str, Any] = {"to": to, "template_key": template_key, **content}
+    if distinct_id is not None:
+        payload["distinct_id"] = distinct_id
+    payload.update(_sender(args))
+    return _PreparedSend(
+        path=_SEND_PATH,
+        body=_encode(payload),
+        idempotency_key=idempotency_key,
+        max_retries=max_retries,
+    )
+
+
+def _sender(args: Mapping[str, Any]) -> dict[str, Any]:
+    sender: dict[str, Any] = {}
+    if "from_" in args:
+        sender["from"] = _nonempty_text(args, "from_")
+    reply_to = _addresses("reply_to", args["reply_to"]) if "reply_to" in args else []
+    if reply_to:
+        sender["reply_to"] = reply_to
+    capture_engagement = args.get("capture_engagement", True)
+    if not isinstance(capture_engagement, bool):
+        raise TypeError("capture_engagement must be True or False.")
+    sender["capture_engagement"] = capture_engagement
+    return sender
+
+
+def _addresses(field: str, value: Any) -> list[str]:
+    addresses = [value] if isinstance(value, str) else value
+    if not isinstance(addresses, Sequence) or not all(
+        isinstance(address, str) for address in addresses
+    ):
+        raise TypeError(f"{field} must be one address or a list of addresses.")
+    if not all(address.strip() for address in addresses):
+        raise ValueError(f"{field} must not hold a blank address.")
+    return list(addresses)
+
+
+def _string(args: Mapping[str, Any], name: str) -> str:
+    value = args[name]
+    if not isinstance(value, str):
+        raise TypeError(f"{name} must be a string.")
+    return value
+
+
+def _nonempty_text(args: Mapping[str, Any], name: str) -> str:
+    value = _string(args, name)
+    if not value:
+        raise ValueError(f"{name} must not be empty.")
+    return value
+
+
+def _encode(payload: Mapping[str, Any]) -> bytes:
+    return json.dumps(
+        payload, cls=DatetimeSerializer, separators=(",", ":"), ensure_ascii=False
+    ).encode("utf-8")
+
+
 def _prepare_send(
     to: str,
     template_id: Union[str, UUID],
@@ -210,10 +427,8 @@ def _prepare_send(
     idempotency_key: Optional[str],
     max_retries: Optional[int] = None,
 ) -> _PreparedSend:
-    if not isinstance(to, str):
-        raise TypeError("to must be one email address as a string.")
-    if not to.strip():
-        raise ValueError("to must not be empty.")
+    to, distinct_id, idempotency_key = _recipient(to, distinct_id, idempotency_key)
+    max_retries = _retry_limit(max_retries)
     try:
         template_uuid = (
             template_id if isinstance(template_id, UUID) else UUID(template_id)
@@ -222,6 +437,29 @@ def _prepare_send(
         raise ValueError("template_id must be the template's UUID.") from None
     if template_data is not None and not isinstance(template_data, Mapping):
         raise TypeError("template_data must be a mapping.")
+
+    payload: dict[str, Any] = {
+        "template_id": str(template_uuid),
+        "to": to,
+        "message_data": clean(dict(template_data or {})),
+    }
+    if distinct_id is not None:
+        payload["distinct_id"] = distinct_id
+    return _PreparedSend(
+        path=_SEND_PATH,
+        body=json.dumps(payload, cls=DatetimeSerializer).encode("utf-8"),
+        idempotency_key=idempotency_key,
+        max_retries=max_retries,
+    )
+
+
+def _recipient(
+    to: Any, distinct_id: Any, idempotency_key: Any
+) -> tuple[str, Optional[str], str]:
+    if not isinstance(to, str):
+        raise TypeError("to must be one email address as a string.")
+    if not to.strip():
+        raise ValueError("to must not be empty.")
     if distinct_id is not None and (
         not isinstance(distinct_id, str) or not distinct_id
     ):
@@ -234,26 +472,17 @@ def _prepare_send(
         raise ValueError(
             "idempotency_key must be 1 to 255 visible ASCII characters without spaces."
         )
+    return to, distinct_id, idempotency_key
+
+
+def _retry_limit(max_retries: Any) -> Optional[int]:
     if max_retries is not None and (
         isinstance(max_retries, bool)
         or not isinstance(max_retries, int)
         or max_retries < 0
     ):
         raise ValueError("max_retries must be a nonnegative integer.")
-
-    payload: dict[str, Any] = {
-        "template_id": str(template_uuid),
-        "to": to,
-        "message_data": clean(dict(template_data or {})),
-    }
-    if distinct_id is not None:
-        payload["distinct_id"] = distinct_id
-    return _PreparedSend(
-        path=_SEND_PATH,
-        body=json.dumps(payload, cls=DatetimeSerializer).encode("utf-8"),
-        idempotency_key=idempotency_key,
-        max_retries=max_retries,
-    )
+    return max_retries
 
 
 def _status_path(message_id: Union[str, UUID]) -> str:
@@ -266,7 +495,9 @@ def _status_path(message_id: Union[str, UUID]) -> str:
     return _STATUS_PATH.format(message_id=message_uuid)
 
 
-def _validate_options(timeout: float, max_retries: int) -> None:
+def _validate_options(
+    timeout: float, max_retries: int, migrated_from: Optional[str]
+) -> None:
     if (
         isinstance(timeout, bool)
         or not isinstance(timeout, (int, float))
@@ -280,6 +511,12 @@ def _validate_options(timeout: float, max_retries: int) -> None:
         or max_retries < 0
     ):
         raise ValueError("max_retries must be a nonnegative integer.")
+    if migrated_from is not None and not (
+        isinstance(migrated_from, str) and _HEADER_TOKEN.fullmatch(migrated_from)
+    ):
+        raise ValueError(
+            "migrated_from must be visible ASCII characters, such as 'resend'."
+        )
 
 
 def _text(value: Any) -> Optional[str]:
@@ -449,24 +686,33 @@ def _log_warnings(result: SendEmailResult) -> None:
         log.warning("PostHog email warning %s: %s", warning.code, warning.message)
 
 
-def _headers(secret_key: str, idempotency_key: Optional[str]) -> dict[str, str]:
+def _headers(
+    secret_key: str,
+    migrated_from: Optional[str],
+    *,
+    has_body: bool = False,
+    idempotency_key: Optional[str] = None,
+) -> dict[str, str]:
     headers = {
         "Authorization": f"Bearer {secret_key}",
         "Accept": "application/json",
         "User-Agent": f"posthog-python/{VERSION}",
     }
-    if idempotency_key is not None:
+    if has_body:
         headers["Content-Type"] = "application/json"
+    if idempotency_key is not None:
         headers["Idempotency-Key"] = idempotency_key
+    if migrated_from is not None:
+        headers["X-PostHog-Migrated-From"] = migrated_from
     return headers
 
 
 _SEND_NOT_DONE = "no email was sent"
 _GET_NOT_DONE = "no email status was read"
-_SEND_KEY_NEEDED = "Sending email needs secret_key, a project secret API key with the hog_flow:write scope."
+_SEND_KEY_NEEDED = "Sending email needs secret_key, a project secret API key with the transactional_email:write scope."
 _GET_KEY_NEEDED = (
     "Reading an email status needs secret_key, a project secret API key with the "
-    "hog_flow:read or hog_flow:write scope."
+    "transactional_email:read or transactional_email:write scope."
 )
 _ResultT = TypeVar("_ResultT")
 _Parse = Callable[[int, Any, Optional[str]], _ResultT]
@@ -491,13 +737,15 @@ def __init__(
         timeout: float,
         max_retries: int,
         disabled: bool,
+        migrated_from: Optional[str],
     ) -> None:
-        _validate_options(timeout, max_retries)
+        _validate_options(timeout, max_retries, migrated_from)
         self.secret_key = secret_key.strip() if isinstance(secret_key, str) else None
         self.host = determine_app_host(host)
         self.timeout = timeout
         self.max_retries = max_retries
         self.disabled = disabled
+        self.migrated_from = migrated_from
         self._parent_disabled: Callable[[], bool] = lambda: False
         self._admit: Callable[[], Optional[Callable[[], None]]] = lambda: _no_op
         self._host_error: Optional[str] = None
@@ -526,7 +774,7 @@ def _secret_key(self, key_needed: str) -> str:
 
 
 class Emails(_EmailsBase):
-    """Sends transactional email from PostHog email templates.
+    """Sends transactional email from PostHog email templates or from content in your code.
 
     ``host`` is your PostHog app host. PostHog Cloud ingestion hosts map to the
     app host, so ``us.i.posthog.com`` sends to ``us.posthog.com``. Any other
@@ -536,7 +784,8 @@ class Emails(_EmailsBase):
     to ``max_retries`` times, with the same idempotency key. Set
     ``max_retries=0`` when a job runner already retries the send. ``timeout``
     is in seconds, per request. Pass ``session`` to send through your own
-    ``requests.Session``, for example a test double.
+    ``requests.Session``, for example a test double. ``migrated_from``, such
+    as ``"resend"``, tells PostHog which provider your sends came from.
     """
 
     def __init__(
@@ -548,6 +797,7 @@ def __init__(
         max_retries: int = 2,
         disabled: bool = False,
         session: Optional[requests.Session] = None,
+        migrated_from: Optional[str] = None,
     ) -> None:
         super().__init__(
             secret_key,
@@ -555,22 +805,25 @@ def __init__(
             timeout=timeout,
             max_retries=max_retries,
             disabled=disabled,
+            migrated_from=migrated_from,
         )
         self._session: Optional[requests.Session] = session
         self._owns_session = session is None
         self._session_lock = threading.Lock()
 
-    def send(
-        self,
-        *,
-        to: str,
-        template_id: Union[str, UUID],
-        template_data: Optional[Mapping[str, Any]] = None,
-        distinct_id: Optional[str] = None,
-        idempotency_key: Optional[str] = None,
-        max_retries: Optional[int] = None,
-    ) -> SendEmailResult:
-        """Queue one email from a transactional email template.
+    @overload
+    def send(self, **kwargs: Unpack[TemplateEmailArgs]) -> SendEmailResult: ...
+
+    @overload
+    def send(self, **kwargs: Unpack[CodeEmailArgs]) -> SendEmailResult: ...
+
+    def send(self, **kwargs: Any) -> SendEmailResult:
+        """Queue one email, from a template in PostHog or from content in your code.
+
+        Pass exactly one form. The template form names a template made in
+        PostHog with ``template_id``. The code form names the email with
+        ``template_key`` and passes ``subject`` and ``html``, ``text`` or both:
+        see :class:`CodeEmailArgs`.
 
         Args:
             to: One recipient email address.
@@ -608,29 +861,40 @@ def send(
                 distinct_id="user_123",
                 idempotency_key="welcome:user_123",
             )
+            emails.send(
+                to="user@example.com",
+                template_key="password-reset",
+                subject="Reset your password",
+                html=rendered_html,
+                distinct_id="user_123",
+            )
             ```
         """
-        prepared = _prepare_send(
-            to, template_id, template_data, distinct_id, idempotency_key, max_retries
-        )
+        prepared = _prepare(kwargs)
         finish = self._start(_SEND_NOT_DONE)
         try:
-            headers = _headers(
-                self._secret_key(_SEND_KEY_NEEDED), prepared.idempotency_key
-            )
-            result = self._call(
-                "POST",
-                prepared.path,
-                prepared.body,
-                headers,
-                _parse_response,
-                prepared.max_retries,
-            )
+            result = self._deliver(prepared, self._secret_key(_SEND_KEY_NEEDED))
         finally:
             finish()
         _log_warnings(result)
         return result
 
+    def _deliver(self, prepared: _PreparedSend, secret_key: str) -> SendEmailResult:
+        headers = _headers(
+            secret_key,
+            self.migrated_from,
+            has_body=True,
+            idempotency_key=prepared.idempotency_key,
+        )
+        return self._call(
+            "POST",
+            prepared.path,
+            prepared.body,
+            headers,
+            _parse_response,
+            prepared.max_retries,
+        )
+
     def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         """Read what happened to an email that :meth:`send` queued.
 
@@ -658,7 +922,7 @@ def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         path = _status_path(message_id)
         finish = self._start(_GET_NOT_DONE)
         try:
-            headers = _headers(self._secret_key(_GET_KEY_NEEDED), None)
+            headers = _headers(self._secret_key(_GET_KEY_NEEDED), self.migrated_from)
             return self._call("GET", path, None, headers, _parse_status_response)
         finally:
             finish()
@@ -753,6 +1017,7 @@ def __init__(
         max_retries: int = 2,
         disabled: bool = False,
         http_client: Any = None,
+        migrated_from: Optional[str] = None,
     ) -> None:
         super().__init__(
             secret_key,
@@ -760,21 +1025,19 @@ def __init__(
             timeout=timeout,
             max_retries=max_retries,
             disabled=disabled,
+            migrated_from=migrated_from,
         )
         self._client: Any = http_client
         self._owns_client = http_client is None
 
-    async def send(
-        self,
-        *,
-        to: str,
-        template_id: Union[str, UUID],
-        template_data: Optional[Mapping[str, Any]] = None,
-        distinct_id: Optional[str] = None,
-        idempotency_key: Optional[str] = None,
-        max_retries: Optional[int] = None,
-    ) -> SendEmailResult:
-        """Queue one email from a transactional email template.
+    @overload
+    async def send(self, **kwargs: Unpack[TemplateEmailArgs]) -> SendEmailResult: ...
+
+    @overload
+    async def send(self, **kwargs: Unpack[CodeEmailArgs]) -> SendEmailResult: ...
+
+    async def send(self, **kwargs: Any) -> SendEmailResult:
+        """Queue one email, from a template in PostHog or from content in your code.
 
         Takes the same arguments and raises the same errors as
         :meth:`Emails.send`.
@@ -789,27 +1052,33 @@ async def send(
             )
             ```
         """
-        prepared = _prepare_send(
-            to, template_id, template_data, distinct_id, idempotency_key, max_retries
-        )
+        prepared = _prepare(kwargs)
         finish = self._start(_SEND_NOT_DONE)
         try:
-            headers = _headers(
-                self._secret_key(_SEND_KEY_NEEDED), prepared.idempotency_key
-            )
-            result = await self._call(
-                "POST",
-                prepared.path,
-                prepared.body,
-                headers,
-                _parse_response,
-                prepared.max_retries,
-            )
+            result = await self._deliver(prepared, self._secret_key(_SEND_KEY_NEEDED))
         finally:
             finish()
         _log_warnings(result)
         return result
 
+    async def _deliver(
+        self, prepared: _PreparedSend, secret_key: str
+    ) -> SendEmailResult:
+        headers = _headers(
+            secret_key,
+            self.migrated_from,
+            has_body=True,
+            idempotency_key=prepared.idempotency_key,
+        )
+        return await self._call(
+            "POST",
+            prepared.path,
+            prepared.body,
+            headers,
+            _parse_response,
+            prepared.max_retries,
+        )
+
     async def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         """Read what happened to an email that :meth:`send` queued.
 
@@ -819,7 +1088,7 @@ async def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         path = _status_path(message_id)
         finish = self._start(_GET_NOT_DONE)
         try:
-            headers = _headers(self._secret_key(_GET_KEY_NEEDED), None)
+            headers = _headers(self._secret_key(_GET_KEY_NEEDED), self.migrated_from)
             return await self._call("GET", path, None, headers, _parse_status_response)
         finally:
             finish()
@@ -915,10 +1184,15 @@ def _client_emails(
     app_host: Optional[str],
     timeout: float,
     max_retries: int,
+    migrated_from: Optional[str],
 ) -> _EmailsT:
     if app_host:
         emails = factory(
-            secret_key, host=app_host, timeout=timeout, max_retries=max_retries
+            secret_key,
+            host=app_host,
+            timeout=timeout,
+            max_retries=max_retries,
+            migrated_from=migrated_from,
         )
         emails._parent_disabled = is_disabled
         emails._admit = admit
@@ -930,6 +1204,7 @@ def _client_emails(
         host=inferred_host if is_cloud else None,
         timeout=timeout,
         max_retries=max_retries,
+        migrated_from=migrated_from,
     )
     if not is_cloud:
         # A custom host is often an ingestion proxy, which must not receive the secret key.
diff --git a/posthog/test/test_emails.py b/posthog/test/test_emails.py
index c0aeac2e8..eaf1c0949 100644
--- a/posthog/test/test_emails.py
+++ b/posthog/test/test_emails.py
@@ -176,6 +176,7 @@ def test_client_email_options_set_the_host_timeout_and_retries():
         app_host="https://posthog.example.com/",
         email_request_timeout_seconds=3,
         email_request_max_retries=0,
+        migrated_from="resend",
     )
     unavailable = response(503, {"code": "delivery_unavailable"})
 
@@ -188,6 +189,35 @@ def test_client_email_options_set_the_host_timeout_and_retries():
     request.assert_called_once()
     assert request.call_args.args[1].startswith("https://posthog.example.com/api/")
     assert request.call_args.kwargs["timeout"] == 3
+    sent = request.call_args.kwargs["auth"](
+        requests.Request("POST", "https://posthog.example.com/").prepare()
+    )
+    assert sent.headers["X-PostHog-Migrated-From"] == "resend"
+
+
+def test_names_the_provider_the_client_moved_from_on_every_request():
+    emails, adapter = emails_with([accepted(), status_reply()], migrated_from="resend")
+
+    send(emails)
+    emails.get(MESSAGE_ID)
+
+    assert [
+        request.headers["X-PostHog-Migrated-From"] for request in adapter.requests
+    ] == [
+        "resend",
+        "resend",
+    ]
+
+
+@parameterized.expand([("space", "re send"), ("not_text", 1), ("empty", "")])
+def test_rejects_a_provider_name_that_is_not_a_header_value(_name, migrated_from):
+    with pytest.raises(ValueError):
+        Posthog(
+            "phc_test",
+            secret_key=SECRET_KEY,
+            sync_mode=True,
+            migrated_from=migrated_from,
+        )
 
 
 @parameterized.expand(
@@ -282,6 +312,18 @@ def test_waits_for_retry_after_and_gives_up_on_a_longer_one(no_sleep):
         ("client_option", {"max_retries": 0}, {}, 1),
         ("per_send_override", {}, {"max_retries": 0}, 1),
         ("per_send_override_above_client", {"max_retries": 0}, {"max_retries": 1}, 2),
+        (
+            "code_send_override",
+            {},
+            {
+                "template_id": None,
+                "template_key": "password-reset",
+                "subject": "Reset",
+                "html": "<p>Reset</p>",
+                "max_retries": 0,
+            },
+            1,
+        ),
     ]
 )
 def test_max_retries_zero_leaves_retries_to_the_caller(
@@ -290,9 +332,12 @@ def test_max_retries_zero_leaves_retries_to_the_caller(
     emails, adapter = emails_with(
         [rejected(503, "delivery_unavailable")] * 3, **client_options
     )
+    args = {"to": "user@example.com", "template_id": TEMPLATE_ID, **send_options}
 
     with pytest.raises(EmailError):
-        send(emails, **send_options)
+        emails.send(
+            **{name: value for name, value in args.items() if value is not None}
+        )
 
     assert len(adapter.requests) == requests_made
 
@@ -572,3 +617,185 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert [(request.method, str(request.url)) for request in seen] == [
         ("GET", STATUS_URL)
     ] * 2
+
+
+HTML = "<p>Reset it here.</p>"
+
+
+def send_code(emails: Emails, **overrides: Any):
+    return emails.send(
+        **{
+            "to": "user@example.com",
+            "template_key": "password-reset",
+            "subject": "Reset your password",
+            **overrides,
+        }
+    )
+
+
+@parameterized.expand(
+    [
+        ("html_only", {"html": HTML}, {"html": HTML}),
+        ("text_only", {"text": "Reset it here."}, {"text": "Reset it here."}),
+        (
+            "every_field",
+            {
+                "html": HTML,
+                "text": "Reset it here.",
+                "from_": "Acme <security@example.com>",
+                "reply_to": "help@example.com",
+                "capture_engagement": False,
+                "distinct_id": "user_123",
+            },
+            {
+                "html": HTML,
+                "text": "Reset it here.",
+                "from": "Acme <security@example.com>",
+                "reply_to": ["help@example.com"],
+                "capture_engagement": False,
+                "distinct_id": "user_123",
+            },
+        ),
+        (
+            "several_reply_to",
+            {"html": HTML, "reply_to": ["a@example.com", "b@example.com"]},
+            {"html": HTML, "reply_to": ["a@example.com", "b@example.com"]},
+        ),
+        (
+            "empty_reply_to_left_out",
+            {"html": HTML, "reply_to": []},
+            {"html": HTML},
+        ),
+        (
+            "none_as_left_out",
+            {
+                "html": HTML,
+                "text": None,
+                "from_": None,
+                "reply_to": None,
+                "capture_engagement": None,
+                "distinct_id": None,
+            },
+            {"html": HTML},
+        ),
+    ]
+)
+def test_rendered_content_is_posted_as_is(_name, overrides, extra_body):
+    emails, adapter = emails_with([accepted("msg_1")])
+
+    result = send_code(emails, idempotency_key="reset:user_123", **overrides)
+
+    assert result.id == "msg_1"
+    [request] = adapter.requests
+    assert (request.method, request.url) == ("POST", SEND_URL)
+    assert request.headers["Idempotency-Key"] == "reset:user_123"
+    assert json.loads(request.body) == {
+        "to": "user@example.com",
+        "template_key": "password-reset",
+        "subject": "Reset your password",
+        "capture_engagement": True,
+        **extra_body,
+    }
+
+
+@pytest.mark.asyncio
+async def test_async_client_posts_rendered_content_and_names_the_provider():
+    seen: list[httpx.Request] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return httpx.Response(202, json={"message_id": "msg_1", "replayed": True})
+
+    client = AsyncPosthog("phc_test", secret_key=SECRET_KEY, migrated_from="resend")
+    client.emails._client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+
+    result = await client.emails.send(
+        to="user@example.com",
+        template_key="password-reset",
+        subject="Reset your password",
+        html=HTML,
+        text="Reset it here.",
+        from_="Acme <security@example.com>",
+        reply_to="help@example.com",
+        capture_engagement=False,
+        distinct_id="user_123",
+        idempotency_key="reset:user_123",
+    )
+    await client.shutdown()
+
+    assert (result.id, result.replayed) == ("msg_1", True)
+    [request] = seen
+    assert (request.method, str(request.url)) == ("POST", SEND_URL)
+    assert request.headers["Authorization"] == f"Bearer {SECRET_KEY}"
+    assert request.headers["Idempotency-Key"] == "reset:user_123"
+    assert request.headers["X-PostHog-Migrated-From"] == "resend"
+    assert json.loads(request.content) == {
+        "to": "user@example.com",
+        "template_key": "password-reset",
+        "subject": "Reset your password",
+        "html": HTML,
+        "text": "Reset it here.",
+        "from": "Acme <security@example.com>",
+        "reply_to": ["help@example.com"],
+        "capture_engagement": False,
+        "distinct_id": "user_123",
+    }
+
+
+@parameterized.expand(
+    [
+        ("both_forms", {"template_id": TEMPLATE_ID, "html": HTML}, TypeError),
+        ("no_form", {"template_key": None}, TypeError),
+        ("no_content", {}, TypeError),
+        ("no_subject", {"subject": None, "html": HTML}, TypeError),
+        ("subject_not_text", {"subject": 1, "html": HTML}, TypeError),
+        ("from_not_text", {"html": HTML, "from_": 1}, TypeError),
+        ("from_keyword", {"html": HTML, "from": "a@example.com"}, TypeError),
+        (
+            "key_with_space",
+            {"template_key": "reset password", "html": HTML},
+            ValueError,
+        ),
+        (
+            "key_with_trailing_newline",
+            {"template_key": "welcome\n", "html": HTML},
+            ValueError,
+        ),
+        ("key_too_long", {"template_key": "k" * 401, "html": HTML}, ValueError),
+        ("empty_html", {"html": ""}, ValueError),
+        ("empty_html_and_text", {"html": "", "text": ""}, ValueError),
+        ("blank_reply_to", {"html": HTML, "reply_to": " "}, ValueError),
+        ("reply_to_not_text", {"html": HTML, "reply_to": 123}, TypeError),
+        (
+            "template_data_on_code_form",
+            {"html": HTML, "template_data": {"first_name": "Jane"}},
+            TypeError,
+        ),
+        ("cc_on_code_form", {"html": HTML, "cc": "a@example.com"}, TypeError),
+        (
+            "capture_engagement_on_template_form",
+            {
+                "template_id": TEMPLATE_ID,
+                "template_key": None,
+                "subject": None,
+                "capture_engagement": False,
+            },
+            TypeError,
+        ),
+    ]
+)
+def test_rejects_a_code_send_that_mixes_or_misses_fields(_name, overrides, error):
+    emails, adapter = emails_with([])
+    args = {
+        "to": "user@example.com",
+        "template_key": "password-reset",
+        "subject": "Reset your password",
+        **overrides,
+    }
+
+    with pytest.raises(error):
+        emails.send(
+            **{name: value for name, value in args.items() if value is not None}
+        )
+
+    assert adapter.requests == []
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index 9db790cea..bfffd5d64 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -760,6 +760,7 @@ attribute posthog.async_client.AsyncClient.is_server = is_server
 attribute posthog.async_client.AsyncClient.log = logging.getLogger('posthog')
 attribute posthog.async_client.AsyncClient.log_captured_exceptions = log_captured_exceptions
 attribute posthog.async_client.AsyncClient.max_retries = max(0, max_retries)
+attribute posthog.async_client.AsyncClient.migrated_from = migrated_from
 attribute posthog.async_client.AsyncClient.on_error = on_error
 attribute posthog.async_client.AsyncClient.personal_api_key = self.secret_key
 attribute posthog.async_client.AsyncClient.project_root = os.getcwd()
@@ -830,6 +831,7 @@ attribute posthog.client.Client.log = logging.getLogger('posthog')
 attribute posthog.client.Client.log_captured_exceptions = log_captured_exceptions
 attribute posthog.client.Client.max_retries = max(0, max_retries)
 attribute posthog.client.Client.metrics: PostHogMetrics
+attribute posthog.client.Client.migrated_from = migrated_from
 attribute posthog.client.Client.on_error = on_error
 attribute posthog.client.Client.personal_api_key = self.secret_key
 attribute posthog.client.Client.poll_interval = poll_interval
@@ -886,6 +888,13 @@ attribute posthog.debug = False
 attribute posthog.default_client = None
 attribute posthog.disable_geoip = True
 attribute posthog.disabled = False
+attribute posthog.emails.CodeEmailArgs.capture_engagement: NotRequired[Optional[bool]]
+attribute posthog.emails.CodeEmailArgs.from_: NotRequired[Optional[str]]
+attribute posthog.emails.CodeEmailArgs.html: NotRequired[Optional[str]]
+attribute posthog.emails.CodeEmailArgs.reply_to: NotRequired[Optional[Union[str, Sequence[str]]]]
+attribute posthog.emails.CodeEmailArgs.subject: str
+attribute posthog.emails.CodeEmailArgs.template_key: str
+attribute posthog.emails.CodeEmailArgs.text: NotRequired[Optional[str]]
 attribute posthog.emails.EmailError.code = code
 attribute posthog.emails.EmailError.docs_url = docs_url
 attribute posthog.emails.EmailError.field = field
@@ -906,6 +915,8 @@ attribute posthog.emails.EmailWarning.message: str
 attribute posthog.emails.SendEmailResult.id: str
 attribute posthog.emails.SendEmailResult.replayed: bool = False
 attribute posthog.emails.SendEmailResult.warnings: tuple[EmailWarning, ...] = ()
+attribute posthog.emails.TemplateEmailArgs.template_data: NotRequired[Optional[Mapping[str, Any]]]
+attribute posthog.emails.TemplateEmailArgs.template_id: Union[str, UUID]
 attribute posthog.enable_exception_autocapture = False
 attribute posthog.enable_exception_autocapture_rate_limiting = False
 attribute posthog.enable_full_ai_capture = False
@@ -1322,21 +1333,23 @@ class posthog.ai.types.TokenUsage
 class posthog.ai.types.ToolInProgress 
 class posthog.args.OptionalCaptureArgs 
 class posthog.args.OptionalSetArgs 
-class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
+class posthog.async_client.AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None)
 class posthog.async_client.AsyncPosthog 
 class posthog.bucketed_rate_limiter.BucketedRateLimiter(bucket_size: Number, refill_rate: Number, refill_interval_seconds: Number, on_bucket_rate_limited: Optional[Callable[[Hashable], None]] = None, clock: Callable[[], float] = time.monotonic)
 class posthog.capture_compression.CaptureCompression 
 class posthog.capture_mode.CaptureMode 
 class posthog.capture_v1.CaptureV1Error(status: int | str, message: str, *, retry_after: Optional[float] = None, request_id: Optional[str] = None, attempts: Optional[int] = None, retry_exhausted: Optional[list[str]] = None, drops: Optional[list[tuple[str, Optional[str]]]] = None)
-class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
+class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, _use_ai_lane=False, _enable_multimodal_capture=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None)
 class posthog.consumer.Consumer(queue, api_key, flush_at=100, host=None, on_error=None, flush_interval=5.0, gzip=False, retries=10, timeout: float = 15, historical_migration=False, endpoint=EVENTS_ENDPOINT, max_msg_size=MAX_MSG_SIZE, capture_mode=CaptureMode.V0, capture_compression=CaptureCompression.NONE)
 class posthog.contexts.ContextScope(parent=None, fresh: bool = False, capture_exceptions: bool = True, client: Optional[Client] = None)
-class posthog.emails.AsyncEmails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, http_client: Any = None)
+class posthog.emails.AsyncEmails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, http_client: Any = None, migrated_from: Optional[str] = None)
+class posthog.emails.CodeEmailArgs 
 class posthog.emails.EmailError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None)
 class posthog.emails.EmailStatus(id: str, status: str, created_at: datetime, status_at: datetime, reason: Optional[str] = None)
 class posthog.emails.EmailWarning(code: str, message: str, fix: Optional[str] = None)
-class posthog.emails.Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None)
+class posthog.emails.Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None, migrated_from: Optional[str] = None)
 class posthog.emails.SendEmailResult(id: str, replayed: bool = False, warnings: tuple[EmailWarning, ...] = ())
+class posthog.emails.TemplateEmailArgs 
 class posthog.exception_capture.ExceptionCapture(client: Client, rate_limiting_enabled=False, bucket_size=DEFAULT_BUCKET_SIZE, refill_rate=DEFAULT_REFILL_RATE, refill_interval_seconds=DEFAULT_REFILL_INTERVAL_SECONDS)
 class posthog.exception_utils.AnnotatedValue(value, metadata)
 class posthog.exception_utils.VariableSizeLimiter(max_size=DEFAULT_TOTAL_VARIABLES_SIZE_LIMIT)
@@ -1836,10 +1849,10 @@ method posthog.contexts.ContextScope.set_distinct_id(distinct_id: str)
 method posthog.contexts.ContextScope.set_session_id(session_id: str)
 method posthog.emails.AsyncEmails.aclose() -> None
 method posthog.emails.AsyncEmails.get(message_id: Union[str, UUID]) -> EmailStatus
-method posthog.emails.AsyncEmails.send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
+method posthog.emails.AsyncEmails.send(**kwargs: Any) -> SendEmailResult
 method posthog.emails.Emails.close() -> None
 method posthog.emails.Emails.get(message_id: Union[str, UUID]) -> EmailStatus
-method posthog.emails.Emails.send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
+method posthog.emails.Emails.send(**kwargs: Any) -> SendEmailResult
 method posthog.exception_capture.ExceptionCapture.capture_exception(exception, metadata=None)
 method posthog.exception_capture.ExceptionCapture.close()
 method posthog.exception_capture.ExceptionCapture.exception_handler(exc_type, exc_value, exc_traceback)

From 51642528ced654f1d2b78884c3b06e3a50f3d2cb Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 12:22:50 +0000
Subject: [PATCH 185/245] chore: Release v7.84.0 [skip ci]

---
 .sampo/changesets/emails-code-form.md         | 28 ----------------
 .../langchain-anthropic-cache-input-tokens.md |  5 ---
 openfeature-provider/CHANGELOG.md             |  6 ++++
 openfeature-provider/pyproject.toml           |  2 +-
 posthog/CHANGELOG.md                          | 33 +++++++++++++++++++
 posthog/version.py                            |  2 +-
 pyproject.toml                                |  2 +-
 uv.lock                                       |  4 +--
 8 files changed, 44 insertions(+), 38 deletions(-)
 delete mode 100644 .sampo/changesets/emails-code-form.md
 delete mode 100644 .sampo/changesets/langchain-anthropic-cache-input-tokens.md

diff --git a/.sampo/changesets/emails-code-form.md b/.sampo/changesets/emails-code-form.md
deleted file mode 100644
index 4264b2b9c..000000000
--- a/.sampo/changesets/emails-code-form.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-pypi/posthog: minor
----
-
-`posthog.emails.send()` can now send email content your code rendered, such as HTML from Jinja or React Email. Give the email a `template_key` and a `subject`, and pass `html`, `text` or both.
-
-```python
-posthog = Posthog("phc_...", secret_key="phs_...")
-
-result = posthog.emails.send(
-    to="user@example.com",
-    distinct_id="user_123",
-    template_key="password-reset",
-    subject="Reset your password",
-    html=rendered_html,
-)
-
-# "delivered", "bounced", ...
-status = posthog.emails.get(result.id).status
-```
-
-You need a project secret API key, the kind that starts with `phs_`. Create one under **Project secret API keys** in your project settings. Set its **Transactional email** scope to Write to send emails, or to Read for a key that only reads statuses. Pass it to the client as `secret_key`. Set `app_host` to your PostHog app URL when you self-host PostHog or send through a reverse proxy.
-
-PostHog records each email's delivery, opens and clicks on the person with that `distinct_id`. It groups every email with the same `template_key`, so you see their metrics and logs in one place. The SDK retries a request that hits a network error, a rate limit or an outage twice by default. Every send carries an idempotency key, so a retry never sends the email twice. Pass your own `idempotency_key`, such as `welcome:user_123`, and your job runner's retries are safe too.
-
-A send with your own content also takes `from_`, `reply_to` and `capture_engagement=False`. Set `migrated_from` on the client to tell PostHog which email provider you moved from. A failed call raises an `EmailError` with PostHog's `code` and the HTTP `status_code`.
-
-Docs: [Send transactional emails with Python](https://posthog.com/docs/workflows/transactional-emails/python) and the [transactional email overview](https://posthog.com/docs/workflows/transactional-emails).
diff --git a/.sampo/changesets/langchain-anthropic-cache-input-tokens.md b/.sampo/changesets/langchain-anthropic-cache-input-tokens.md
deleted file mode 100644
index fd34d4c9b..000000000
--- a/.sampo/changesets/langchain-anthropic-cache-input-tokens.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-The LangChain callback handler no longer reports too few input tokens for a non-streamed `ChatAnthropic` call that reads or writes the prompt cache. It took the raw Anthropic usage from `response_metadata`, whose input tokens already exclude the cache, and subtracted the cache tokens again, so a cached call usually reported 0 input tokens. It now reads LangChain's standard `usage_metadata` first, as it already did for streamed calls.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 5f4baf347..336ec6c04 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.145 — 2026-11-05
+
+### Patch changes
+
+- Updated dependencies: posthog@7.84.0
+
 ## 0.1.144 — 2026-11-05
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 557f2b63a..bfdbc08e8 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.144"
+version = "0.1.145"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index c97e61fa6..7abd0e6c9 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,38 @@
 # posthog
 
+## 7.84.0 — 2026-11-05
+
+### Minor changes
+
+- [063f1ce](https://github.com/posthog/posthog-python/commit/063f1cece68ee0d6e4d644d4b6fe0fbe335e3b29) `posthog.emails.send()` can now send email content your code rendered, such as HTML from Jinja or React Email. Give the email a `template_key` and a `subject`, and pass `html`, `text` or both.
+  
+  ```python
+  posthog = Posthog("phc_...", secret_key="phs_...")
+  
+  result = posthog.emails.send(
+      to="user@example.com",
+      distinct_id="user_123",
+      template_key="password-reset",
+      subject="Reset your password",
+      html=rendered_html,
+  )
+  
+  # "delivered", "bounced", ...
+  status = posthog.emails.get(result.id).status
+  ```
+  
+  You need a project secret API key, the kind that starts with `phs_`. Create one under **Project secret API keys** in your project settings. Set its **Transactional email** scope to Write to send emails, or to Read for a key that only reads statuses. Pass it to the client as `secret_key`. Set `app_host` to your PostHog app URL when you self-host PostHog or send through a reverse proxy.
+  
+  PostHog records each email's delivery, opens and clicks on the person with that `distinct_id`. It groups every email with the same `template_key`, so you see their metrics and logs in one place. The SDK retries a request that hits a network error, a rate limit or an outage twice by default. Every send carries an idempotency key, so a retry never sends the email twice. Pass your own `idempotency_key`, such as `welcome:user_123`, and your job runner's retries are safe too.
+  
+  A send with your own content also takes `from_`, `reply_to` and `capture_engagement=False`. Set `migrated_from` on the client to tell PostHog which email provider you moved from. A failed call raises an `EmailError` with PostHog's `code` and the HTTP `status_code`.
+  
+  Docs: [Send transactional emails with Python](https://posthog.com/docs/workflows/transactional-emails/python) and the [transactional email overview](https://posthog.com/docs/workflows/transactional-emails). — Thanks @Silthus!
+
+### Patch changes
+
+- [b741c65](https://github.com/posthog/posthog-python/commit/b741c65a5cd0e503aaf915e695cdb4d54686d9f9) The LangChain callback handler no longer reports too few input tokens for a non-streamed `ChatAnthropic` call that reads or writes the prompt cache. It took the raw Anthropic usage from `response_metadata`, whose input tokens already exclude the cache, and subtracted the cache tokens again, so a cached call usually reported 0 input tokens. It now reads LangChain's standard `usage_metadata` first, as it already did for streamed calls. — Thanks @jaeminbird for your first contribution 🎉!
+
 ## 7.83.3 — 2026-11-05
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index f1b455dd8..667885390 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.83.3"
+VERSION = "7.84.0"
diff --git a/pyproject.toml b/pyproject.toml
index 3dc2ac953..cc6c9414c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.83.3"
+version = "7.84.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 359a9041f..0a6ebf568 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.144"
+version = "0.1.145"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.83.3"
+version = "7.84.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 5febc73aa74b38376a9d9cac895552686cefaca2 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 12:22:56 +0000
Subject: [PATCH 186/245] Update generated references

---
 .../posthog-python-references-7.84.0.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    8 +-
 2 files changed, 3579 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.84.0.json

diff --git a/references/posthog-python-references-7.84.0.json b/references/posthog-python-references-7.84.0.json
new file mode 100644
index 000000000..d02a4ee15
--- /dev/null
+++ b/references/posthog-python-references-7.84.0.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.84.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index b68caab6f..d02a4ee15 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.83.3",
+    "version": "7.84.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",
@@ -678,6 +678,12 @@
               "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
               "isOptional": false,
               "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
             }
           ],
           "showDocs": true,

From f3116ffca51ba3dcac8527bb0c50505bab079bdc Mon Sep 17 00:00:00 2001
From: Lucas Faria <12522524+lucasheriques@users.noreply.github.com>
Date: Thu, 5 Nov 2026 17:41:02 -0300
Subject: [PATCH 187/245] fix(mcp): reword injected descriptions so directory
 review stops flagging them (#1191)

* fix(mcp): reword injected argument descriptions for directory review

What: reworded the descriptions of the injected conversation_id and llm_model
arguments and the get_more_tools and send_feedback virtual tools (plus the
feedback_type property) so each states what the field is and that it is
recorded for analytics. Removed behavioral instructions and broad-triggering
lines. Descriptions only: names, annotations, schemas and the canned
get_more_tools reply are unchanged. Adds a patch sampo changeset.

Why: the ChatGPT and Claude directory reviews flag descriptions that tell the
model how to behave beyond one call or ask to be triggered broadly.

Tests:
- pytest posthog/test/mcp (PYTHONPATH=worktree): 665 passed, 10 skipped
- new parameterized test_advertised_descriptions_carry_no_behavioral_instructions
  failed 6/6 on the old text, passes now
- ruff format --check / ruff check on posthog/mcp and posthog/test/mcp: clean

Reviewer note: test_units asserted the old conversation_id clause "rest of the
conversation, including after later user messages"; its comment says ChatGPT
drops the handle without it. The new wording drops that clause as specified, so
session continuity on ChatGPT is worth watching.

* fix(mcp): keep the cross-message clause in the conversation_id description

posthog-js#5112 added "for the rest of the conversation, including after
later user messages" because ChatGPT otherwise drops the handle on the
first call of each new user message. Keep that semantics; it describes
the field, not unrelated model behaviour. The parallel-calls and
different-task instructions stay out.
---
 .../mcp-reword-injected-descriptions.md       |  5 +++
 posthog/mcp/constants.py                      | 14 +++---
 posthog/mcp/feedback.py                       | 11 ++---
 posthog/mcp/tools.py                          |  4 +-
 posthog/test/mcp/test_feedback.py             | 44 ++++++++++++++++++-
 posthog/test/mcp/test_units.py                |  2 +-
 6 files changed, 60 insertions(+), 20 deletions(-)
 create mode 100644 .sampo/changesets/mcp-reword-injected-descriptions.md

diff --git a/.sampo/changesets/mcp-reword-injected-descriptions.md b/.sampo/changesets/mcp-reword-injected-descriptions.md
new file mode 100644
index 000000000..7354cf9a6
--- /dev/null
+++ b/.sampo/changesets/mcp-reword-injected-descriptions.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Reworded the descriptions of the injected `conversation_id` and `llm_model` arguments and the `get_more_tools` and `send_feedback` virtual tools so they describe the field instead of instructing the model. This changes your published tool definitions; if your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools.
diff --git a/posthog/mcp/constants.py b/posthog/mcp/constants.py
index de359e693..47a2b2c62 100644
--- a/posthog/mcp/constants.py
+++ b/posthog/mcp/constants.py
@@ -28,18 +28,14 @@
 )
 
 DEFAULT_CONVERSATION_ID_DESCRIPTION = (
-    "Pass the exact conversation_id from the server's previous response, unchanged. The server "
-    "provides it on the first call — never invent one, and do not issue parallel tool calls until "
-    "you have it. Keep passing the same conversation_id for the rest of the conversation, including "
-    "after later user messages or on a different task; do not reset it when the user starts a new "
-    "request."
+    "The conversation_id this server returned earlier in this conversation, unchanged, including "
+    "after later user messages. Omit it if you have none. Recorded for the server developer's "
+    "analytics."
 )
 
 DEFAULT_MODEL_PARAMETER_DESCRIPTION = (
-    "The exact model identifier you (the assistant) are running as, taken from your "
-    'system prompt or environment (e.g. "claude-opus-4-8", "gpt-5.2"). Used for '
-    'analytics only. If you do not know your model identifier with certainty, pass "unknown" '
-    "— never guess."
+    'The model identifier you are running as, for example "claude-opus-4-8" or "gpt-5.2". '
+    'Pass "unknown" if you are not certain. Recorded for the server developer\'s analytics.'
 )
 
 POSTHOG_MCP_ANALYTICS_SOURCE = "posthog_mcp_analytics"
diff --git a/posthog/mcp/feedback.py b/posthog/mcp/feedback.py
index fcba7fad1..fd937070b 100644
--- a/posthog/mcp/feedback.py
+++ b/posthog/mcp/feedback.py
@@ -28,11 +28,9 @@
 _TRUNCATION_SUFFIX = "..."
 
 _DEFAULT_FEEDBACK_DESCRIPTION = (
-    "Send feedback about this server to its developers. Most important: report a missing "
-    "capability whenever no available tool fits your task, even if you can work around it "
-    '(feedback_type "missing_capability"). Also welcome: a tool that failed or confused you, '
-    "an unhelpful error, or something that worked well. This records the feedback; it does "
-    "not add or change tools. Do not include user PII or sensitive content."
+    "Send feedback about this server to its developers: a capability you needed that no tool "
+    "provides, a tool that failed or misled you, or something that worked well. Records the "
+    "feedback; it does not add or change tools. Leave out personal or sensitive details."
 )
 
 _SEND_FEEDBACK_RESULT_TEXT = (
@@ -47,8 +45,7 @@
         "description": (
             "What kind of feedback this is. Use 'missing_capability' when the tool you "
             "needed does not exist in the tool list - nothing failed, the capability is "
-            "absent (this is the most valuable report; send it even if you found a "
-            "workaround). Use 'issue' when an existing tool behaved badly: it failed, "
+            "absent. Use 'issue' when an existing tool behaved badly: it failed, "
             "returned a confusing error, or its description or schema misled you. Use "
             "'praise' when something worked notably well. Use 'other' for anything else."
         ),
diff --git a/posthog/mcp/tools.py b/posthog/mcp/tools.py
index ef59b7a28..97d4bb6eb 100644
--- a/posthog/mcp/tools.py
+++ b/posthog/mcp/tools.py
@@ -39,8 +39,8 @@ def build_report_missing_descriptor(name: str = GET_MORE_TOOLS_NAME) -> Dict[str
     return {
         "name": name,
         "description": (
-            "Check for additional tools whenever your task might benefit from specialized "
-            "capabilities - even if existing tools could work as a fallback."
+            "Report that the user's request needs a capability this server does not have. "
+            "Records the report for the server's developers; it does not return or add tools."
         ),
         "inputSchema": {
             "type": "object",
diff --git a/posthog/test/mcp/test_feedback.py b/posthog/test/mcp/test_feedback.py
index 87274dcca..315623546 100644
--- a/posthog/test/mcp/test_feedback.py
+++ b/posthog/test/mcp/test_feedback.py
@@ -88,7 +88,7 @@ async def _list_tools_lowlevel(server):
 def test_descriptor_defaults():
     descriptor = get_feedback_tool_descriptor()
     assert descriptor["name"] == SEND_FEEDBACK_TOOL_NAME
-    assert "missing capability" in descriptor["description"]
+    assert "a capability you needed that no tool provides" in descriptor["description"]
     assert descriptor["inputSchema"]["required"] == ["feedback_type", "summary"]
     assert set(descriptor["inputSchema"]["properties"]) == {
         "feedback_type",
@@ -540,6 +540,48 @@ async def test_fastmcp_coexists_with_report_missing():
     assert _events(client, "$mcp_tool_call") == []
 
 
+def _descriptions(node):
+    if isinstance(node, dict):
+        for key, value in node.items():
+            if key == "description" and isinstance(value, str):
+                yield value
+            yield from _descriptions(value)
+    elif isinstance(node, list):
+        for item in node:
+            yield from _descriptions(item)
+
+
+@pytest.mark.parametrize(
+    "phrase",
+    [
+        "parallel tool calls",
+        "system prompt",
+        "even if existing tools",
+        "Most important",
+        "even if you can work around it",
+        "send it even if",
+    ],
+)
+async def test_advertised_descriptions_carry_no_behavioral_instructions(phrase):
+    server = make_fastmcp()
+    instrument(
+        server,
+        FakeClient(),
+        MCPAnalyticsOptions(
+            report_missing=True, collect_feedback=True, capture_model=True
+        ),
+    )
+
+    list_handler = server._mcp_server.request_handlers[mcp_types.ListToolsRequest]
+    result = await list_handler(mcp_types.ListToolsRequest(method="tools/list"))
+    tools = result.root.tools
+    assert {"add", "get_more_tools", "send_feedback"} <= {t.name for t in tools}
+    descriptions = list(_descriptions([t.model_dump() for t in tools]))
+
+    assert descriptions
+    assert not [d for d in descriptions if phrase.lower() in d.lower()]
+
+
 # --- on_feedback -----------------------------------------------------------------
 
 
diff --git a/posthog/test/mcp/test_units.py b/posthog/test/mcp/test_units.py
index 49316a1fb..f5a3546c3 100644
--- a/posthog/test/mcp/test_units.py
+++ b/posthog/test/mcp/test_units.py
@@ -235,7 +235,7 @@ def test_add_conversation_id_adds_property():
     assert out["properties"]["conversation_id"]["type"] == "string"
     # Without this clause, ChatGPT drops the handle on each new user message and every message becomes its own session.
     assert (
-        "rest of the conversation, including after later user messages"
+        "including after later user messages"
         in out["properties"]["conversation_id"]["description"]
     )
 

From 780f5c01cdf25b31ce8ce03f648a3f1fbb1a6c58 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 23:48:13 +0000
Subject: [PATCH 188/245] chore: Release v7.84.1 [skip ci]

---
 .sampo/changesets/mcp-reword-injected-descriptions.md | 5 -----
 openfeature-provider/CHANGELOG.md                     | 6 ++++++
 openfeature-provider/pyproject.toml                   | 2 +-
 posthog/CHANGELOG.md                                  | 6 ++++++
 posthog/version.py                                    | 2 +-
 pyproject.toml                                        | 2 +-
 uv.lock                                               | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-reword-injected-descriptions.md

diff --git a/.sampo/changesets/mcp-reword-injected-descriptions.md b/.sampo/changesets/mcp-reword-injected-descriptions.md
deleted file mode 100644
index 7354cf9a6..000000000
--- a/.sampo/changesets/mcp-reword-injected-descriptions.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Reworded the descriptions of the injected `conversation_id` and `llm_model` arguments and the `get_more_tools` and `send_feedback` virtual tools so they describe the field instead of instructing the model. This changes your published tool definitions; if your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 336ec6c04..20f31d5ed 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.146 — 2026-11-05
+
+### Patch changes
+
+- Updated dependencies: posthog@7.84.1
+
 ## 0.1.145 — 2026-11-05
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index bfdbc08e8..3ed7c4178 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.145"
+version = "0.1.146"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 7abd0e6c9..1f9b970b0 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.84.1 — 2026-11-05
+
+### Patch changes
+
+- [f3116ff](https://github.com/posthog/posthog-python/commit/f3116ffca51ba3dcac8527bb0c50505bab079bdc) Reworded the descriptions of the injected `conversation_id` and `llm_model` arguments and the `get_more_tools` and `send_feedback` virtual tools so they describe the field instead of instructing the model. This changes your published tool definitions; if your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools. — Thanks @lucasheriques!
+
 ## 7.84.0 — 2026-11-05
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 667885390..9868aceff 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.84.0"
+VERSION = "7.84.1"
diff --git a/pyproject.toml b/pyproject.toml
index cc6c9414c..5a948b14b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.84.0"
+version = "7.84.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 0a6ebf568..5d32ed4b3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.145"
+version = "0.1.146"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.84.0"
+version = "7.84.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 6b7c0ba3e72b8ebdc3b1f65aedafbb44c7c67256 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Thu, 5 Nov 2026 23:48:18 +0000
Subject: [PATCH 189/245] Update generated references

---
 .../posthog-python-references-7.84.1.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.84.1.json

diff --git a/references/posthog-python-references-7.84.1.json b/references/posthog-python-references-7.84.1.json
new file mode 100644
index 000000000..0da4e84b5
--- /dev/null
+++ b/references/posthog-python-references-7.84.1.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.84.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index d02a4ee15..0da4e84b5 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.84.0",
+    "version": "7.84.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 11585fba6517aa3c33e657e5b94103e65469563e Mon Sep 17 00:00:00 2001
From: Luan Taraschi <130802253+luantaraschi@users.noreply.github.com>
Date: Fri, 6 Nov 2026 05:14:12 -0300
Subject: [PATCH 190/245] fix(flags): do not retry a refused flags connection
 (#1180)

* fix(flags): do not retry a refused flags connection

A refused connection is not transient, so flags() now raises it on the first attempt instead of retrying it on the backoff schedule. Timeouts, resets, DNS and TLS failures are still retried.

* fix(flags): ignore unrelated handled exceptions when detecting a refusal

A timeout raised while the application handles its own refused connection was treated as a refusal and not retried.

* fix: use namespaced package key in flags changeset

---------

Co-authored-by: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Co-authored-by: Manoel Aranda Neto <marandaneto@gmail.com>
---
 .../flags-no-retry-connection-refused.md      |  5 ++
 posthog/request.py                            | 32 ++++++++++-
 posthog/test/test_request.py                  | 55 +++++++++++++++++++
 3 files changed, 90 insertions(+), 2 deletions(-)
 create mode 100644 .sampo/changesets/flags-no-retry-connection-refused.md

diff --git a/.sampo/changesets/flags-no-retry-connection-refused.md b/.sampo/changesets/flags-no-retry-connection-refused.md
new file mode 100644
index 000000000..e5a465d32
--- /dev/null
+++ b/.sampo/changesets/flags-no-retry-connection-refused.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Stop retrying `/flags` requests when the connection is refused, so the flag error surfaces right away instead of after the retry backoff.
diff --git a/posthog/request.py b/posthog/request.py
index 03316fc1f..52854f922 100644
--- a/posthog/request.py
+++ b/posthog/request.py
@@ -15,6 +15,7 @@
 import requests
 from requests.adapters import HTTPAdapter
 from urllib3.connection import HTTPConnection
+from urllib3.exceptions import NewConnectionError
 from urllib3.util.retry import Retry
 
 from posthog._logging import _configure_posthog_logging
@@ -322,6 +323,29 @@ def _process_response(
         raise APIError(res.status_code, res.text, retry_after=retry_after)
 
 
+def _is_connection_refused(exc: BaseException) -> bool:
+    """Return True when a requests transport error wraps a refused connection."""
+    pending: List[Any] = [exc]
+    seen = set()
+    while pending:
+        current = pending.pop()
+        if current is None or id(current) in seen:
+            continue
+        seen.add(id(current))
+        if isinstance(current, ConnectionRefusedError):
+            return True
+        if isinstance(current, BaseException):
+            pending.extend(current.args)
+            pending.append(current.__cause__)
+            # __context__ records whatever exception was being handled, which may
+            # have nothing to do with this request. urllib3 1.x only links the
+            # socket error to NewConnectionError that way, so follow it just there.
+            if isinstance(current, NewConnectionError):
+                pending.append(current.__context__)
+        pending.append(getattr(current, "reason", None))
+    return False
+
+
 def _feature_flags_retry_delay(failed_attempt: int) -> float:
     return _FEATURE_FLAGS_RETRY_BACKOFF_SECONDS * (2**failed_attempt)
 
@@ -354,8 +378,12 @@ def flags(
             return _process_response(
                 res, success_message="Feature flags evaluated successfully"
             )
-        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
-            if failed_attempt >= retries:
+        except (
+            requests.exceptions.ConnectionError,
+            requests.exceptions.Timeout,
+        ) as exc:
+            # A refused connection is not transient, so it is not retried.
+            if failed_attempt >= retries or _is_connection_refused(exc):
                 raise
         except APIError as exc:
             if (
diff --git a/posthog/test/test_request.py b/posthog/test/test_request.py
index e23b0a446..d9d44df79 100644
--- a/posthog/test/test_request.py
+++ b/posthog/test/test_request.py
@@ -1,5 +1,6 @@
 import gzip
 import json
+import socket
 import unittest
 import zlib
 from datetime import date, datetime, timedelta
@@ -702,6 +703,60 @@ def test_flags_retries_transport_errors_once_by_default(
         self.assertEqual(mock_session.post.call_count, 2)
         mock_sleep.assert_called_once_with(0.3)
 
+    @mock.patch("posthog.request.time.sleep")
+    def test_flags_does_not_retry_refused_connection(self, mock_sleep):
+        # Bind and close a socket so the port refuses connections.
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.bind(("127.0.0.1", 0))
+            port = sock.getsockname()[1]
+
+        with mock.patch("posthog.request.post", wraps=request_module.post) as mock_post:
+            with self.assertRaises(requests.exceptions.ConnectionError):
+                flags(
+                    "test-key",
+                    f"http://127.0.0.1:{port}",
+                    max_retries=2,
+                    distinct_id="user123",
+                )
+
+        self.assertEqual(mock_post.call_count, 1)
+        mock_sleep.assert_not_called()
+
+    @mock.patch("posthog.request.time.sleep")
+    @mock.patch("posthog.request._get_flags_session")
+    def test_flags_retries_when_handling_an_unrelated_refused_connection(
+        self, mock_get_flags_session, mock_sleep
+    ):
+        mock_response = requests.Response()
+        mock_response.status_code = 200
+        mock_response._content = json.dumps(
+            {
+                "featureFlags": {"test-flag": True},
+                "featureFlagPayloads": {},
+                "errorsWhileComputingFlags": False,
+            }
+        ).encode("utf-8")
+
+        mock_session = mock.MagicMock()
+        mock_session.post.side_effect = [
+            requests.exceptions.Timeout("timed out"),
+            mock_response,
+        ]
+        mock_get_flags_session.return_value = mock_session
+
+        # The application evaluates flags while handling its own refused
+        # connection, so the timeout inherits that error as its __context__.
+        try:
+            raise ConnectionRefusedError("database is down")
+        except ConnectionRefusedError:
+            response = flags(
+                "test-key", "https://test.posthog.com", distinct_id="user123"
+            )
+
+        self.assertEqual(response["featureFlags"], {"test-flag": True})
+        self.assertEqual(mock_session.post.call_count, 2)
+        mock_sleep.assert_called_once_with(0.3)
+
     @mock.patch("posthog.request.time.sleep")
     @mock.patch("posthog.request._get_flags_session")
     def test_flags_retry_count_zero_disables_retries(

From acbc71e16e97afa907bacfd0447bea423cbc1e67 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 08:17:22 +0000
Subject: [PATCH 191/245] chore: Release v7.84.2 [skip ci]

---
 .sampo/changesets/flags-no-retry-connection-refused.md | 5 -----
 openfeature-provider/CHANGELOG.md                      | 6 ++++++
 openfeature-provider/pyproject.toml                    | 2 +-
 posthog/CHANGELOG.md                                   | 6 ++++++
 posthog/version.py                                     | 2 +-
 pyproject.toml                                         | 2 +-
 uv.lock                                                | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/flags-no-retry-connection-refused.md

diff --git a/.sampo/changesets/flags-no-retry-connection-refused.md b/.sampo/changesets/flags-no-retry-connection-refused.md
deleted file mode 100644
index e5a465d32..000000000
--- a/.sampo/changesets/flags-no-retry-connection-refused.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Stop retrying `/flags` requests when the connection is refused, so the flag error surfaces right away instead of after the retry backoff.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 20f31d5ed..365bbf682 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.147 — 2026-11-06
+
+### Patch changes
+
+- Updated dependencies: posthog@7.84.2
+
 ## 0.1.146 — 2026-11-05
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3ed7c4178..8d4768014 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.146"
+version = "0.1.147"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 1f9b970b0..865df253e 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.84.2 — 2026-11-06
+
+### Patch changes
+
+- [11585fb](https://github.com/posthog/posthog-python/commit/11585fba6517aa3c33e657e5b94103e65469563e) Stop retrying `/flags` requests when the connection is refused, so the flag error surfaces right away instead of after the retry backoff. — Thanks @luantaraschi!
+
 ## 7.84.1 — 2026-11-05
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 9868aceff..fb037dd03 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.84.1"
+VERSION = "7.84.2"
diff --git a/pyproject.toml b/pyproject.toml
index 5a948b14b..c621472c3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.84.1"
+version = "7.84.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 5d32ed4b3..c69e7c909 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.146"
+version = "0.1.147"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.84.1"
+version = "7.84.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 5f5665ccab46e6e47bb90fd9270c967bf9ca0296 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 08:17:27 +0000
Subject: [PATCH 192/245] Update generated references

---
 .../posthog-python-references-7.84.2.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.84.2.json

diff --git a/references/posthog-python-references-7.84.2.json b/references/posthog-python-references-7.84.2.json
new file mode 100644
index 000000000..26ee3007a
--- /dev/null
+++ b/references/posthog-python-references-7.84.2.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.84.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 0da4e84b5..26ee3007a 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.84.1",
+    "version": "7.84.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 3f93a347939779e63f0176bf0a1396b07f98002c Mon Sep 17 00:00:00 2001
From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
Date: Fri, 6 Nov 2026 20:35:40 +0700
Subject: [PATCH 193/245] fix(flags): skip client-only definition warnings
 (#1198)

---
 .../client-runtime-definition-warnings.md     |   5 +
 posthog/client.py                             |   2 +
 posthog/test/test_evaluate_flags.py           | 173 ++++++++++++++++++
 3 files changed, 180 insertions(+)
 create mode 100644 .sampo/changesets/client-runtime-definition-warnings.md

diff --git a/.sampo/changesets/client-runtime-definition-warnings.md b/.sampo/changesets/client-runtime-definition-warnings.md
new file mode 100644
index 000000000..07a3aedac
--- /dev/null
+++ b/.sampo/changesets/client-runtime-definition-warnings.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Exclude client-only feature flags from definition-load warnings about experience continuity and unsupported definitions, without changing local evaluation.
diff --git a/posthog/client.py b/posthog/client.py
index 87ba50705..66c161866 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -3538,6 +3538,8 @@ def _classify_unresolvable_flags(
         unresolvable: Dict[str, Tuple[UnresolvedFlagReason, str]] = {}
         for flag in snapshot["flags"]:
             try:
+                if flag.get("evaluation_runtime") == "client":
+                    continue
                 key = flag["key"]
                 reason = _get_definition_unresolved_reason(
                     flag,
diff --git a/posthog/test/test_evaluate_flags.py b/posthog/test/test_evaluate_flags.py
index d22be7719..dbe33583c 100644
--- a/posthog/test/test_evaluate_flags.py
+++ b/posthog/test/test_evaluate_flags.py
@@ -1,3 +1,4 @@
+import json
 import logging
 import unittest
 import warnings
@@ -1254,6 +1255,178 @@ def test_removed_flag_is_forgotten_and_warns_again_when_it_returns(self):
             len(self._warnings(logs, "checkout", "experience_continuity")), 2
         )
 
+    def _refresh_from(self, client, source, *flags):
+        definitions = json.loads(json.dumps(self._definitions(*flags)))
+        if source == "api":
+            self._refresh(
+                client,
+                GetResponse(data=definitions, etag="etag-1", not_modified=False),
+            )
+        else:
+            cache_provider = mock.Mock()
+            cache_provider.should_fetch_flag_definitions.return_value = False
+            cache_provider.get_flag_definitions.return_value = definitions
+            with (
+                mock.patch.object(
+                    client, "_flag_definition_cache_provider", cache_provider
+                ),
+                mock.patch("posthog.client.get") as get,
+            ):
+                client._load_feature_flags()
+                get.assert_not_called()
+
+    @staticmethod
+    def _never_resolvable_flag(key, reason, **kwargs):
+        flag = (
+            _always_on_flag(key, ensure_experience_continuity=True)
+            if reason == "experience_continuity"
+            else _flag_with(key, _STATIC_COHORT)
+        )
+        return {**flag, "version": 7, **kwargs}
+
+    @parameterized.expand(
+        [
+            (source, reason, runtime_name, runtime_fields)
+            for source in ("api", "cache")
+            for reason in ("experience_continuity", "unsupported_definition")
+            for runtime_name, runtime_fields in (
+                ("client", {"evaluation_runtime": "client"}),
+                ("server", {"evaluation_runtime": "server"}),
+                ("all", {"evaluation_runtime": "all"}),
+                ("null", {"evaluation_runtime": None}),
+                ("absent", {}),
+            )
+        ]
+    )
+    @mock.patch("posthog.client.flags")
+    def test_warning_runtime_json_semantics_and_deduplication(
+        self, source, reason, runtime_name, runtime_fields, patch_flags
+    ):
+        client = self._client()
+        checkout = self._never_resolvable_flag("checkout", reason, **runtime_fields)
+        with self.assertLogs("posthog", level=logging.DEBUG) as logs:
+            self._refresh_from(client, source, checkout)
+            self._refresh_from(client, source, checkout)
+            if source == "api":
+                self._refresh(
+                    client,
+                    GetResponse(data=None, etag="etag-1", not_modified=True),
+                )
+
+        self.assertEqual(
+            len(self._warnings(logs, "checkout", reason)),
+            0 if runtime_name == "client" else 1,
+        )
+        self.assertEqual(client.feature_flags, [checkout])
+        self.assertEqual(
+            set(client._warned_unresolvable_flags),
+            set() if runtime_name == "client" else {"checkout"},
+        )
+        patch_flags.assert_not_called()
+
+    @parameterized.expand([("api",), ("cache",)])
+    @mock.patch("posthog.client.flags")
+    def test_mixed_runtime_warning_counts_and_names(self, source, patch_flags):
+        client = self._client()
+        definitions = [
+            self._never_resolvable_flag(f"{reason}-{runtime_name}", reason, **fields)
+            for reason in ("experience_continuity", "unsupported_definition")
+            for runtime_name, fields in (
+                ("client", {"evaluation_runtime": "client"}),
+                ("server", {"evaluation_runtime": "server"}),
+                ("all", {"evaluation_runtime": "all"}),
+                ("null", {"evaluation_runtime": None}),
+                ("absent", {}),
+            )
+        ]
+        with self.assertLogs("posthog", level=logging.WARNING) as logs:
+            self._refresh_from(client, source, *definitions)
+            self._refresh_from(client, source, *definitions)
+
+        self.assertEqual(len(logs.records), 2)
+        for reason in ("experience_continuity", "unsupported_definition"):
+            messages = self._warnings(logs, reason, reason)
+            self.assertEqual(len(messages), 1)
+            message = messages[0].getMessage()
+            self.assertIn("4 flag(s)", message)
+            self.assertNotIn(f"{reason}-client", message)
+            for runtime_name in ("server", "all", "null", "absent"):
+                self.assertIn(f"{reason}-{runtime_name}", message)
+        self.assertEqual(client.feature_flags, definitions)
+        patch_flags.assert_not_called()
+
+    @parameterized.expand(
+        [
+            (source, reason, runtime_name, runtime_fields)
+            for source in ("api", "cache")
+            for reason in ("experience_continuity", "unsupported_definition")
+            for runtime_name, runtime_fields in (
+                ("server", {"evaluation_runtime": "server"}),
+                ("all", {"evaluation_runtime": "all"}),
+                ("null", {"evaluation_runtime": None}),
+                ("absent", {}),
+            )
+        ]
+    )
+    @mock.patch("posthog.client.flags")
+    def test_client_runtime_forgets_history_before_nonclient_return(
+        self, source, reason, runtime_name, runtime_fields, patch_flags
+    ):
+        client = self._client()
+        server = self._never_resolvable_flag(
+            "checkout", reason, evaluation_runtime="server"
+        )
+        client_only = {**server, "evaluation_runtime": "client"}
+        returning = self._never_resolvable_flag("checkout", reason, **runtime_fields)
+        with self.assertLogs("posthog", level=logging.DEBUG) as logs:
+            self._refresh_from(client, source, server)
+            self.assertEqual(len(self._warnings(logs, "checkout", reason)), 1)
+            for expected_count in (2, 3):
+                self._refresh_from(client, source, client_only)
+                self._refresh_from(client, source, client_only)
+                self.assertEqual(client._warned_unresolvable_flags, {})
+                self.assertEqual(
+                    len(self._warnings(logs, "checkout", reason)), expected_count - 1
+                )
+                self._refresh_from(client, source, returning)
+                self._refresh_from(client, source, returning)
+                self.assertEqual(
+                    len(self._warnings(logs, "checkout", reason)), expected_count
+                )
+                self.assertEqual(client.feature_flags, [returning])
+        patch_flags.assert_not_called()
+
+    @parameterized.expand([("api",), ("cache",)])
+    @mock.patch("posthog.client.flags")
+    def test_client_runtime_preserves_local_value_and_unresolved_reasons(
+        self, source, patch_flags
+    ):
+        client = self._client()
+        definitions = [
+            _always_on_flag("client-flag", evaluation_runtime="client"),
+            self._never_resolvable_flag(
+                "continuity", "experience_continuity", evaluation_runtime="client"
+            ),
+            self._never_resolvable_flag(
+                "unsupported", "unsupported_definition", evaluation_runtime="client"
+            ),
+        ]
+        with self.assertNoLogs("posthog", level=logging.WARNING):
+            self._refresh_from(client, source, *definitions)
+            snapshot = client.evaluate_flags("user-123", only_evaluate_locally=True)
+
+        self.assertEqual(snapshot.keys, ["client-flag"])
+        self.assertIs(snapshot.get_flag("client-flag"), True)
+        self.assertEqual(
+            dict(snapshot.unresolved_flags),
+            {
+                "continuity": UnresolvedFlagReason.EXPERIENCE_CONTINUITY,
+                "unsupported": UnresolvedFlagReason.UNSUPPORTED_DEFINITION,
+            },
+        )
+        self.assertEqual(client.feature_flags, definitions)
+        patch_flags.assert_not_called()
+
     def test_classifies_and_logs_outside_the_publication_lock(self):
         client = self._client()
         lock = client._flag_definition_publication_lock

From 44d817e490fad0c90fc0a389b48feeaef7707d9d Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 13:37:14 +0000
Subject: [PATCH 194/245] chore: Release v7.84.3 [skip ci]

---
 .sampo/changesets/client-runtime-definition-warnings.md | 5 -----
 openfeature-provider/CHANGELOG.md                       | 6 ++++++
 openfeature-provider/pyproject.toml                     | 2 +-
 posthog/CHANGELOG.md                                    | 6 ++++++
 posthog/version.py                                      | 2 +-
 pyproject.toml                                          | 2 +-
 uv.lock                                                 | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/client-runtime-definition-warnings.md

diff --git a/.sampo/changesets/client-runtime-definition-warnings.md b/.sampo/changesets/client-runtime-definition-warnings.md
deleted file mode 100644
index 07a3aedac..000000000
--- a/.sampo/changesets/client-runtime-definition-warnings.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Exclude client-only feature flags from definition-load warnings about experience continuity and unsupported definitions, without changing local evaluation.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 365bbf682..1280779b6 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.148 — 2026-11-06
+
+### Patch changes
+
+- Updated dependencies: posthog@7.84.3
+
 ## 0.1.147 — 2026-11-06
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 8d4768014..b3f842cb8 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.147"
+version = "0.1.148"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 865df253e..5cba76f83 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.84.3 — 2026-11-06
+
+### Patch changes
+
+- [3f93a34](https://github.com/posthog/posthog-python/commit/3f93a347939779e63f0176bf0a1396b07f98002c) Exclude client-only feature flags from definition-load warnings about experience continuity and unsupported definitions, without changing local evaluation. — Thanks @marandaneto!
+
 ## 7.84.2 — 2026-11-06
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index fb037dd03..eb64e2076 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.84.2"
+VERSION = "7.84.3"
diff --git a/pyproject.toml b/pyproject.toml
index c621472c3..3a0b4f266 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.84.2"
+version = "7.84.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index c69e7c909..06de1fae2 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.147"
+version = "0.1.148"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.84.2"
+version = "7.84.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 1402030092d31e8598e4853264be3fc341c8f8fc Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 13:37:20 +0000
Subject: [PATCH 195/245] Update generated references

---
 .../posthog-python-references-7.84.3.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.84.3.json

diff --git a/references/posthog-python-references-7.84.3.json b/references/posthog-python-references-7.84.3.json
new file mode 100644
index 000000000..343650524
--- /dev/null
+++ b/references/posthog-python-references-7.84.3.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.84.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 26ee3007a..343650524 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.84.2",
+    "version": "7.84.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 778f386eaacd1ea9379852c3b032a9f19a6271ea Mon Sep 17 00:00:00 2001
From: Lucas Faria <12522524+lucasheriques@users.noreply.github.com>
Date: Fri, 6 Nov 2026 17:36:02 -0300
Subject: [PATCH 196/245] feat(mcp): tell directory reviews what the virtual
 tools record (#1204)

feat(mcp): align tool listing with the directory review commitments

What: `get_more_tools` and `send_feedback` declare readOnlyHint,
destructiveHint, idempotentHint and openWorldHint as false with no title
(shared VIRTUAL_TOOL_HINTS). The injected `context` description is the short
cross-SDK text. `llm_model` is never added to a schema's `required` list.

Why: promised to OpenAI's plugin directory review. A call records an event in
the server owner's project, so the old read-only/idempotent hints were wrong.
Split from posthog-python#1199 so this has no public API change.

Tested with: pytest posthog/test/mcp on the 1.x, v2 and fastmcp-2 venvs (670,
518, 665 passed); ruff format/check, mypy-baseline filter and
`make public_api_check` clean (snapshot unchanged).

Reviewer note: on the fastmcp-2 venv
test_fastmcp_v2.py::test_jlowin_middleware_defaults_work_across_fresh_instances
fails identically on origin/main, unrelated to this change.
---
 .sampo/changesets/mcp-directory-listing.md | 11 +++++
 posthog/mcp/README.md                      | 14 +++----
 posthog/mcp/_instrumentation.py            |  9 +---
 posthog/mcp/_model_parameters.py           | 12 ++----
 posthog/mcp/constants.py                   | 10 ++---
 posthog/mcp/feedback.py                    | 13 +-----
 posthog/mcp/tools.py                       | 18 ++++----
 posthog/test/mcp/test_fastmcp.py           |  2 +-
 posthog/test/mcp/test_feedback.py          |  7 ----
 posthog/test/mcp/test_model_parameters.py  |  2 +-
 posthog/test/mcp/test_posthog_mcp.py       | 22 +++++++++-
 posthog/test/mcp/test_v2_wire_dual_era.py  |  2 +-
 posthog/test/mcp/test_virtual_tools.py     | 48 ++++++++++++++++++++++
 13 files changed, 110 insertions(+), 60 deletions(-)
 create mode 100644 .sampo/changesets/mcp-directory-listing.md

diff --git a/.sampo/changesets/mcp-directory-listing.md b/.sampo/changesets/mcp-directory-listing.md
new file mode 100644
index 000000000..4faf7a796
--- /dev/null
+++ b/.sampo/changesets/mcp-directory-listing.md
@@ -0,0 +1,11 @@
+---
+pypi/posthog: minor
+---
+
+MCP analytics tool definitions change in three ways:
+
+- `get_more_tools` and `send_feedback` declare `readOnlyHint`, `destructiveHint`, `idempotentHint`, and `openWorldHint` as `false`, because a call records data in your PostHog project. Their annotations no longer carry a `title`.
+- The injected `context` argument has a shorter description.
+- The injected `llm_model` argument is always optional.
+
+These changes alter your published tool definitions. If your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index bd179597d..58f177233 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -145,9 +145,9 @@ contains the sanitized tool arguments and their original names.
 Custom dispatchers can call `get_tool_input_properties()` and add its result to
 the `properties` argument of `capture_tool_call()`.
 
-Model capture adds an `llm_model` argument to compatible tool schemas, required on the official
-high-level adapters and optional elsewhere. Dispatch never enforces it, so servers keep working;
-strict-schema clients see the new field. Set `capture_model=False` to leave schemas untouched.
+Model capture adds an optional `llm_model` argument to compatible tool schemas. Dispatch never
+enforces it, so servers keep working; strict-schema clients see the new field. Set
+`capture_model=False` to leave schemas untouched.
 Conversation correlation adds an optional `conversation_id` argument and returns a handle in
 eligible tool results. Clients must echo it to group later calls; calls without it mint new handles.
 Set `enable_conversation_id=False` to retain transport-based session grouping and unchanged
@@ -161,11 +161,9 @@ The SDK records the best model identifier visible to the server as
 `$mcp_llm_model`. Recognized client metadata wins and sets
 `$mcp_llm_model_source` to `client_metadata`. The SDK also adds an `llm_model`
 string to each compatible tool schema as a fallback, recorded with source
-`self_reported`. It is required for custom dispatchers and the official high-level
-MCP SDK adapters. Raw low-level servers and standalone `fastmcp.FastMCP` advertise
-it as optional; the standalone adapter strips it before input validation, so
-requiring it would reject calls. Existing schema strictness is preserved when
-analytics fields are added.
+`self_reported`. It is always optional: an agent that does not know its model would
+otherwise guess one. Existing schema strictness is preserved when analytics fields
+are added.
 
 The recognized metadata path is Codex's `x-codex-turn-metadata.model` field in
 request `_meta`. Other clients, including Claude Code, use the self-report path
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index cd87dd4a2..ae8d7b30b 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -1180,9 +1180,7 @@ def mutate_tool_schema(
             required=context_required,
         )
     if inject_model:
-        schema = _mutate_model_schema(
-            data, tool.name, schema, required=context_required
-        )
+        schema = _mutate_model_schema(data, tool.name, schema)
     else:
         # Discard any earlier registered-tool verdict: middleware may now
         # advertise or dispatch an application-owned field with the same name.
@@ -1202,9 +1200,7 @@ def mutate_tool_schema(
         )
 
 
-def _mutate_model_schema(
-    data: MCPAnalyticsData, name: str, schema: Any, *, required: bool
-) -> Any:
+def _mutate_model_schema(data: MCPAnalyticsData, name: str, schema: Any) -> Any:
     if not is_capture_model_enabled(data.options.capture_model):
         return schema
     model_was_injected = data.tool_model_parameter_injected.get(name, False)
@@ -1214,7 +1210,6 @@ def _mutate_model_schema(
             schema,
             name,
             get_model_description(data.options.capture_model),
-            required=required,
         )
     data.tool_model_parameter_injected[name] = not app_owns_model and schema_has_param(
         schema, "llm_model"
diff --git a/posthog/mcp/_model_parameters.py b/posthog/mcp/_model_parameters.py
index 05ee0f29f..be26fd14c 100644
--- a/posthog/mcp/_model_parameters.py
+++ b/posthog/mcp/_model_parameters.py
@@ -33,9 +33,10 @@ def add_model_parameter_to_schema(
     input_schema: Optional[Dict[str, Any]],
     tool_name: str = "unknown",
     description_override: Optional[str] = None,
-    required: bool = True,
 ) -> Optional[Dict[str, Any]]:
-    """Return a copied schema with an SDK-owned ``llm_model`` field.
+    """Return a copied schema with an optional, SDK-owned ``llm_model`` field.
+    Never required: an agent that does not know its model would guess one, and
+    a model the client sends in request ``_meta`` wins anyway.
 
     Existing application fields and complex schemas fail closed: the SDK must
     never overwrite or later strip a value that belongs to the tool itself.
@@ -58,13 +59,6 @@ def add_model_parameter_to_schema(
         "type": "string",
         "description": description_override or DEFAULT_MODEL_PARAMETER_DESCRIPTION,
     }
-    if required:
-        required_list = schema.get("required")
-        if isinstance(required_list, list):
-            if "llm_model" not in required_list:
-                required_list.append("llm_model")
-        else:
-            schema["required"] = ["llm_model"]
     return schema
 
 
diff --git a/posthog/mcp/constants.py b/posthog/mcp/constants.py
index 47a2b2c62..5fc725b35 100644
--- a/posthog/mcp/constants.py
+++ b/posthog/mcp/constants.py
@@ -18,13 +18,9 @@
 INACTIVITY_TIMEOUT_IN_MINUTES = 30
 
 DEFAULT_CONTEXT_PARAMETER_DESCRIPTION = (
-    "Explain in 15-25 words, in third person, why this tool is called and how it supports "
-    "the user's goal. For analytics only. You MUST describe only the abstract purpose of the "
-    "tool call. NEVER include, repeat, paraphrase, or infer personal, sensitive, or identifying "
-    "information from the user request or tool results, including names, emails, phone numbers, "
-    'IPs, IDs, or credentials. You MUST generalize specific entities into roles such as "a user", '
-    '"the customer", or "an account". Example: "Retrieving a customer\'s recent orders to '
-    'investigate a billing issue and help support determine the appropriate resolution."'
+    "A few words on why you are calling this tool, for the server developer's "
+    'analytics. Describe people and things by role, such as "a customer". Do not '
+    "quote the user or include names, emails, or other personal details."
 )
 
 DEFAULT_CONVERSATION_ID_DESCRIPTION = (
diff --git a/posthog/mcp/feedback.py b/posthog/mcp/feedback.py
index fd937070b..5d1bc1d08 100644
--- a/posthog/mcp/feedback.py
+++ b/posthog/mcp/feedback.py
@@ -13,6 +13,7 @@
 from ._sanitization import sanitize_free_text, sanitize_free_text_value
 from .constants import PostHogMCPAnalyticsProperty
 from .logger import log
+from .tools import VIRTUAL_TOOL_HINTS
 from .types import CollectFeedbackOptions, FeedbackReport, JsonRecord
 
 __all__ = ["SEND_FEEDBACK_TOOL_NAME", "send_feedback_result"]
@@ -168,17 +169,7 @@ def get_feedback_tool_descriptor(
             "properties": properties,
             "required": ["feedback_type", "summary", *extra_required],
         },
-        "annotations": {
-            "title": "Send feedback",
-            "readOnlyHint": True,
-            # Interacts with an external entity: the report lands in analytics.
-            "openWorldHint": True,
-            # Only records the feedback, so repeat calls are harmless — and
-            # advertising it as idempotent makes agents more willing to call it
-            # proactively.
-            "idempotentHint": True,
-            "destructiveHint": False,
-        },
+        "annotations": dict(VIRTUAL_TOOL_HINTS),
     }
 
 
diff --git a/posthog/mcp/tools.py b/posthog/mcp/tools.py
index 97d4bb6eb..36222bf96 100644
--- a/posthog/mcp/tools.py
+++ b/posthog/mcp/tools.py
@@ -16,6 +16,16 @@
 
 GET_MORE_TOOLS_NAME = "get_more_tools"
 
+# A call records one event in the server owner's PostHog project: a write
+# outside the conversation that deletes nothing, repeats on every call, and
+# reaches only that project. Fixed so host configuration cannot misdeclare it.
+VIRTUAL_TOOL_HINTS = {
+    "readOnlyHint": False,
+    "destructiveHint": False,
+    "idempotentHint": False,
+    "openWorldHint": False,
+}
+
 _GET_MORE_TOOLS_RESULT_TEXT = (
     "Unfortunately, we have shown you the full tool list. We have noted your feedback "
     "and will work to improve the tool list in the future."
@@ -52,13 +62,7 @@ def build_report_missing_descriptor(name: str = GET_MORE_TOOLS_NAME) -> Dict[str
             },
             "required": ["context"],
         },
-        "annotations": {
-            "title": "Get More Tools",
-            "readOnlyHint": True,
-            "openWorldHint": True,
-            "idempotentHint": True,
-            "destructiveHint": False,
-        },
+        "annotations": dict(VIRTUAL_TOOL_HINTS),
     }
 
 
diff --git a/posthog/test/mcp/test_fastmcp.py b/posthog/test/mcp/test_fastmcp.py
index 53cdfea34..5be832d69 100644
--- a/posthog/test/mcp/test_fastmcp.py
+++ b/posthog/test/mcp/test_fastmcp.py
@@ -82,7 +82,7 @@ async def test_list_tools_injects_model_into_real_and_virtual_tools():
 
     for name in ("add", "boom", "get_more_tools"):
         assert "llm_model" in tools[name].inputSchema["properties"]
-        assert "llm_model" in tools[name].inputSchema["required"]
+        assert "llm_model" not in tools[name].inputSchema.get("required", [])
 
 
 async def test_virtual_tool_uses_conversation_id():
diff --git a/posthog/test/mcp/test_feedback.py b/posthog/test/mcp/test_feedback.py
index 315623546..b45721c38 100644
--- a/posthog/test/mcp/test_feedback.py
+++ b/posthog/test/mcp/test_feedback.py
@@ -100,13 +100,6 @@ def test_descriptor_defaults():
         "sentiment",
         "task_completed",
     }
-    assert descriptor["annotations"] == {
-        "title": "Send feedback",
-        "readOnlyHint": True,
-        "openWorldHint": True,
-        "idempotentHint": True,
-        "destructiveHint": False,
-    }
 
 
 def test_descriptor_merges_extras_and_custom_name():
diff --git a/posthog/test/mcp/test_model_parameters.py b/posthog/test/mcp/test_model_parameters.py
index 0891f0e95..1c2620f8c 100644
--- a/posthog/test/mcp/test_model_parameters.py
+++ b/posthog/test/mcp/test_model_parameters.py
@@ -31,7 +31,7 @@ def test_add_model_parameter_to_schema(schema):
         "type": "string",
         "description": DEFAULT_MODEL_PARAMETER_DESCRIPTION,
     }
-    assert "llm_model" in result["required"]
+    assert "llm_model" not in result.get("required", [])
     assert result.get("additionalProperties") == (schema or {}).get(
         "additionalProperties"
     )
diff --git a/posthog/test/mcp/test_posthog_mcp.py b/posthog/test/mcp/test_posthog_mcp.py
index 1251db910..51bbb679b 100644
--- a/posthog/test/mcp/test_posthog_mcp.py
+++ b/posthog/test/mcp/test_posthog_mcp.py
@@ -286,6 +286,26 @@ def test_prepare_tool_list_injects_context_into_tool_objects(sdk_tool: bool) ->
     assert "context" not in schema["properties"]
 
 
+# The spec's text, pinned on purpose: every SDK sends this exact string, and
+# importing the constant would make this test agree with any change to it.
+_CROSS_SDK_CONTEXT_DESCRIPTION = (
+    "A few words on why you are calling this tool, for the server developer's "
+    'analytics. Describe people and things by role, such as "a customer". Do not '
+    "quote the user or include names, emails, or other personal details."
+)
+
+
+def test_prepare_tool_list_advertises_the_cross_sdk_context_description():
+    client, _ = make_client()
+    tools = [{"name": "search", "inputSchema": {"type": "object", "properties": {}}}]
+
+    prepared = client.prepare_tool_list(tools)
+
+    assert prepared[0]["inputSchema"]["properties"]["context"]["description"] == (
+        _CROSS_SDK_CONTEXT_DESCRIPTION
+    )
+
+
 def test_prepare_tool_list_can_be_disabled():
     client, _ = make_client()
     tools = [{"name": "search", "inputSchema": {"type": "object", "properties": {}}}]
@@ -309,7 +329,7 @@ async def test_prepare_and_capture_model(options: dict[str, bool]) -> None:
     prepared_tools = client.prepare_tool_list(tools)
     schema = prepared_tools[0]["inputSchema"]
     assert ("llm_model" in schema["properties"]) == enabled
-    assert ("llm_model" in schema.get("required", [])) == enabled
+    assert "llm_model" not in schema.get("required", [])
 
     call = client.prepare_tool_call(
         "search",
diff --git a/posthog/test/mcp/test_v2_wire_dual_era.py b/posthog/test/mcp/test_v2_wire_dual_era.py
index 58fbf4e9a..df5f23235 100644
--- a/posthog/test/mcp/test_v2_wire_dual_era.py
+++ b/posthog/test/mcp/test_v2_wire_dual_era.py
@@ -146,7 +146,7 @@ async def test_modern_tools_list_advertises_injected_params():
     assert "context" in tools["add"]["inputSchema"]["properties"]
     assert "conversation_id" in tools["add"]["inputSchema"]["properties"]
     assert "llm_model" in tools["add"]["inputSchema"]["properties"]
-    assert "llm_model" in tools["add"]["inputSchema"]["required"]
+    assert "llm_model" not in tools["add"]["inputSchema"]["required"]
 
     listed = _events(client, "$mcp_tools_list")
     assert listed and set(listed[0]["properties"]["$mcp_listed_tool_names"]) == {
diff --git a/posthog/test/mcp/test_virtual_tools.py b/posthog/test/mcp/test_virtual_tools.py
index c02ecc7bf..4e45ed31f 100644
--- a/posthog/test/mcp/test_virtual_tools.py
+++ b/posthog/test/mcp/test_virtual_tools.py
@@ -89,6 +89,54 @@ async def test_both_virtual_tools_are_appended_to_the_first_page_only():
     assert _names(await _list_page(server, cursor="1")) == ["echo"]
 
 
+# --- annotations ---------------------------------------------------------------
+
+# The spec's annotations JSON, pinned on purpose: importing VIRTUAL_TOOL_HINTS
+# would make this test agree with any change to it.
+_RECORDS_DATA = {
+    "readOnlyHint": False,
+    "destructiveHint": False,
+    "idempotentHint": False,
+    "openWorldHint": False,
+}
+
+
+@pytest.mark.parametrize(
+    "options, advertised_name",
+    [
+        (MCPAnalyticsOptions(report_missing=True), "get_more_tools"),
+        (MCPAnalyticsOptions(collect_feedback=True), "send_feedback"),
+        (
+            MCPAnalyticsOptions(
+                report_missing=True, missing_capability_tool_name="request_tool"
+            ),
+            "request_tool",
+        ),
+        (
+            MCPAnalyticsOptions(
+                collect_feedback=CollectFeedbackOptions(
+                    tool_name="rate_server", description="Tell us how it went."
+                )
+            ),
+            "rate_server",
+        ),
+    ],
+)
+async def test_virtual_tools_declare_that_they_record_data(options, advertised_name):
+    server = FastMCP("annotations")
+
+    @server.tool()
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    instrument(server, FakeClient(), options)
+    handler = server._mcp_server.request_handlers[mcp_types.ListToolsRequest]
+    result = await handler(mcp_types.ListToolsRequest(method="tools/list"))
+    tool = {t.name: t for t in result.root.tools}[advertised_name]
+
+    assert tool.annotations.model_dump(exclude_none=True) == (_RECORDS_DATA)
+
+
 # --- name collisions -----------------------------------------------------------
 
 

From 5ed0bbedffbb7ee41b95bdbdcc2b8c288db416fe Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 21:10:48 +0000
Subject: [PATCH 197/245] chore: Release v7.85.0 [skip ci]

---
 .sampo/changesets/mcp-directory-listing.md | 11 -----------
 openfeature-provider/CHANGELOG.md          |  6 ++++++
 openfeature-provider/pyproject.toml        |  2 +-
 posthog/CHANGELOG.md                       | 12 ++++++++++++
 posthog/version.py                         |  2 +-
 pyproject.toml                             |  2 +-
 uv.lock                                    |  4 ++--
 7 files changed, 23 insertions(+), 16 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-directory-listing.md

diff --git a/.sampo/changesets/mcp-directory-listing.md b/.sampo/changesets/mcp-directory-listing.md
deleted file mode 100644
index 4faf7a796..000000000
--- a/.sampo/changesets/mcp-directory-listing.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-pypi/posthog: minor
----
-
-MCP analytics tool definitions change in three ways:
-
-- `get_more_tools` and `send_feedback` declare `readOnlyHint`, `destructiveHint`, `idempotentHint`, and `openWorldHint` as `false`, because a call records data in your PostHog project. Their annotations no longer carry a `title`.
-- The injected `context` argument has a shorter description.
-- The injected `llm_model` argument is always optional.
-
-These changes alter your published tool definitions. If your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 1280779b6..b1b4af81d 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.149 — 2026-11-06
+
+### Patch changes
+
+- Updated dependencies: posthog@7.85.0
+
 ## 0.1.148 — 2026-11-06
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index b3f842cb8..63ca07ae1 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.148"
+version = "0.1.149"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5cba76f83..ac145095c 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,17 @@
 # posthog
 
+## 7.85.0 — 2026-11-06
+
+### Minor changes
+
+- [778f386](https://github.com/posthog/posthog-python/commit/778f386eaacd1ea9379852c3b032a9f19a6271ea) MCP analytics tool definitions change in three ways:
+  
+  - `get_more_tools` and `send_feedback` declare `readOnlyHint`, `destructiveHint`, `idempotentHint`, and `openWorldHint` as `false`, because a call records data in your PostHog project. Their annotations no longer carry a `title`.
+  - The injected `context` argument has a shorter description.
+  - The injected `llm_model` argument is always optional.
+  
+  These changes alter your published tool definitions. If your server is listed in the ChatGPT or Claude directories, those platforms may re-review the updated tools. — Thanks @lucasheriques!
+
 ## 7.84.3 — 2026-11-06
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index eb64e2076..070428720 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.84.3"
+VERSION = "7.85.0"
diff --git a/pyproject.toml b/pyproject.toml
index 3a0b4f266..01a40cf23 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.84.3"
+version = "7.85.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 06de1fae2..2f9644122 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.148"
+version = "0.1.149"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.84.3"
+version = "7.85.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From a1dd81cd7091cca20fd14ba4df60d65ced1b9aee Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 21:10:53 +0000
Subject: [PATCH 198/245] Update generated references

---
 .../posthog-python-references-7.85.0.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.85.0.json

diff --git a/references/posthog-python-references-7.85.0.json b/references/posthog-python-references-7.85.0.json
new file mode 100644
index 000000000..8d26a3229
--- /dev/null
+++ b/references/posthog-python-references-7.85.0.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.85.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 343650524..8d26a3229 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.84.3",
+    "version": "7.85.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 0aa5df18d1c60769de1307677b1e0e649eb023e8 Mon Sep 17 00:00:00 2001
From: Lucas Faria <12522524+lucasheriques@users.noreply.github.com>
Date: Fri, 6 Nov 2026 18:39:55 -0300
Subject: [PATCH 199/245] feat(mcp): align posthog.mcp with the sdk-specs MCP
 spec (#1199)

* feat(mcp): align posthog.mcp with the sdk-specs MCP spec before v1

What:
- get_more_tools and send_feedback annotate readOnlyHint, destructiveHint,
  idempotentHint and openWorldHint as false, with no title, so the spec's
  exact annotations JSON matches. Hosts cannot override them.
- The injected `context` argument uses the spec's shared description string.
- `llm_model` is never added to a schema's `required` list.
- A tools/call naming a tool the server never registered sends
  $mcp_unknown_tool (tool name, identity, session) instead of
  $mcp_tool_call and $exception. The client gets the same response.
  A disabled tool, invalid arguments, a raw server with no tools/list
  handler or a name missing from a paginated first page, and standalone
  FastMCP with dispatch-overriding middleware stay failed tool calls.
  PostHogMCP.capture_unknown_tool() covers custom dispatchers.
- Every adapter's raise path and isError-result path calls one
  ToolCallLifecycle.record_if_unknown_tool(). The standalone FastMCP
  registry lookup and its middleware check moved to _instrumentation.py,
  so _instrument_v2 no longer imports from _instrument_lowlevel.
- Minor sampo changeset.

Why: posthog.mcp is about to be declared stable. Customers' insights over
$mcp_* events must not shift after that, so every SDK matches the spec now.

Tested:
- pytest posthog/test/mcp: 678 passed, 10 skipped
- annotations test compares the exact JSON; fails 2/4 with a title present
- ruff format --check . and ruff check .: clean
- mypy --no-site-packages --config-file mypy.ini . | mypy-baseline filter: clean
- python -W error -c "import posthog": ok; make public_api_check: up to date
- full pytest without provider API keys: 6142 passed, 3 failed in
  test_metrics_autocapture.py fork tests (macOS objc fork-safety abort,
  unrelated to this change)

Reviewer notes: _standalone_tool_exists catches the cached fastmcp
not-found errors, which include DisabledError; get_tool raises only
NotFoundError in fastmcp 2.14 and 3.2, so a disabled tool still reads
as existing. Client conversation ids are untouched (posthog-python#1193).

* fix(mcp): close unknown-tool gaps found in review of the spec alignment

What:
- A disabled tool on a mounted FastMCP 3+ server stays a failed
  $mcp_tool_call. A server serving other providers (mounts, proxies)
  can't prove a name absent, so existence answers "can't tell".
- FastMCP's stock middleware (logging, timing, error handling, retry,
  rate limiting, ping, auth, caching, response limiting) no longer hides
  the registry. Tool-injection middleware and app middleware still do.
- A call naming no tool emits nothing, automatic or manual.
- Truncated strings fit their limit with the "..." marker included, so
  $mcp_tool_name stops at 256 characters (the spec's Property reference).
- first_listing_page reads nextCursor only when next_cursor is absent,
  so fastmcp 4 on MCP 2 logs no deprecation warning.
- A raw server's unknown-tool error result carries the conversation
  handle again, and $mcp_unknown_tool carries it once delivered, as
  origin/main did and as posthog-js does.
- Unknown-tool tests skip only the FastMCP.disable cases on fastmcp 2.
- Changeset names the listing probe and hidden-tool upgrade differences.

Why: posthog.mcp must match the sdk-specs MCP spec before it is declared
stable, so customers' insights don't shift afterwards.

Tested:
- pytest posthog/test/mcp (mcp 1.30 + fastmcp 3.2): 694 passed, 11 skipped
- test_unknown_tool.py on mcp 1.30 + fastmcp 2.14.7: 21 passed, 4 skipped;
  mcp 2.3: 15 passed, 10 skipped; mcp 2.3 + fastmcp 4.1.6: 25 passed
- ruff format --check, ruff check, mypy | mypy-baseline filter,
  make public_api_check: clean

Reviewer notes: posthog-js truncates with the marker past the limit too
and needs the same fix. test_fastmcp_v2.py::
test_jlowin_middleware_defaults_work_across_fresh_instances fails on
fastmcp 2.14.7 on origin/main as well ($mcp_input_keys is
["[redacted]"]); not touched here.

* fix(mcp): bound the listing probe and give manual capture a session

What: raw_listing_owns_tool_name waits at most LISTING_PROBE_DEADLINE_SECONDS (1s)
for the host's tools/list and treats a timeout as None (can't tell), so a failed
call records a failed $mcp_tool_call and the client gets its error promptly.
PostHogMCP._base_event mints a fresh ses_<UUIDv7> when no session_id is passed,
so capture_unknown_tool (and capture_tool_call and the other manual captures)
no longer send no $session_id and an anonymous distinct_id.

Why: PostHog Review on #1199. A stalled tools/list handler held every failed
call forever; the spec's Session identity and Manual capture require a
non-empty $session_id, fresh per call when nothing groups it.

Tested: pytest posthog/test/mcp (697 passed, 11 skipped); ruff format/check,
mypy | mypy-baseline filter, make public_api_check all clean. New tests failed
first: stalled listing (timed out), manual capture without session (KeyError).

Reviewer: a manual capture passing conversation_id but no session_id still gets
a fresh session, not one derived from the handle.

* fix(mcp): make the stalled-listing test stall on mcp 2.x

What: `_raw(stall_listing=True)` now stalls every tools/list on mcp 2.x; on 1.x it
still spares the server's own cache refresh.

Why: the v2 adapter probes the host listing as `original(ctx, None)`, and the
helper stalled only when a request was present, so the probe was answered at once,
the call was recorded as `$mcp_unknown_tool`, and the test found no
`$mcp_tool_call` (CI: MCP SDK v2 and v2-bare, Python 3.10). The product code was
right: the deadline path falls back to a failed call on mcp 2.

Tested: `pytest posthog/test/mcp` on mcp 1.30 + fastmcp 3.2 (697 passed), mcp 2.3
(536), mcp 2.3 + fastmcp 4.1.6 (579), and Python 3.10 with mcp 2.x bare (536) and
with fastmcp 4 (579). Raising the deadline to 999s makes the test fail on mcp 2.
ruff format/check and mypy baseline clean.

* fix(mcp): stop treating a tools/list listing as proof a tool is unknown

A call is now unknown only on authoritative evidence: jlowin FastMCP's
registry when nothing overrides dispatch, or the official high-level
server's registry. A raw low-level server's own dispatcher decides which
names exist and its listing may hide tools it serves, so there the SDK
answers "can't tell" and records a failed $mcp_tool_call (spec, "Tool
call event"). This removes the failure-path listing probe, its one-second
deadline, the pagination flag and FirstListingPage.

The deadline also sat in the check that decides whether get_more_tools
and send_feedback are virtual-tool calls, so a tools/list slower than one
second sent those calls to the application. That check is back to
origin/main's.

Tested with:
- new tests failed on the previous head: a slow tools/list still answers
  get_more_tools and send_feedback; a raw low-level server records a
  failed $mcp_tool_call for an unknown name and for a hidden tool
- pytest posthog/test/mcp: .venv (mcp 1.30, fastmcp 3.2) 696 passed;
  v2 (mcp 2.3) 533 passed; v2f4 (mcp 2.3, fastmcp 4.1) 577 passed;
  f2 (mcp 1.30, fastmcp 2.14) 688 passed, 1 failed
- ruff format --check, ruff check, mypy | mypy-baseline filter,
  make public_api_check: clean

Reviewer notes: the f2 failure,
test_jlowin_middleware_defaults_work_across_fresh_instances, also fails
on origin/main in that venv. The unknown-tool handle-delivery test now
covers the error-result branch through standalone FastMCP, since a raw
low-level server no longer records unknown tools.

* fix(mcp): drop the manual unknown-tool API and shrink the spec alignment

What: removed the public PostHogMCP.capture_unknown_tool() and the public
PostHogMCPAnalyticsEvent.UNKNOWN_TOOL constant; the event name now lives in the
private event-name map. The registry helpers stay in _instrument_lowlevel next
to _dispatch_can_differ instead of moving to _instrumentation. Dropped the
slow-listing and hidden-tool test cases (they guarded a listing probe this
branch no longer has and pass on main), the lowlevel test fixture edits, and
README text that documented #1204's annotations. The manual-session test moved
to test_posthog_mcp.py.

Why: stamphog refused #1199 for a public API change and its size. The spec
makes manual capture methods optional, so capture_unknown_tool can return in
its own PR.

Tested with: pytest posthog/test/mcp on .venv, v2, f2, v2f4 (689, 526, 681,
570 passed; f2's one failure is
test_jlowin_middleware_defaults_work_across_fresh_instances, failing on main
until #1203). ruff format/check, mypy-baseline filter clean. make
public_api_check: snapshot up to date, identical to origin/main.

* fix(mcp): treat FastMCP 2.x mounts as unable to rule out a tool

Review: _serves_other_providers only checked FastMCP 3.x providers, so on 2.x
a mounted server (or one whose mount failed to load) made a missing name look
unregistered and emitted $mcp_unknown_tool instead of a failed tool call. It
now also checks 2.x's _mounted_servers.

Tested: new server-with-mounted-server case fails on fastmcp 2.14.7 before the
fix and passes after; pytest posthog/test/mcp on fastmcp 3.2 (690 passed),
2.14.7 and mcp 2.3+fastmcp 4.1 (only failures are the stdio handshake tests,
which fail locally without this change, and the 2.x input-keys test that
posthog-python#1203 fixes); ruff clean.
---
 .sampo/changesets/mcp-v1-spec-align.md |  10 +
 posthog/mcp/README.md                  |  23 +-
 posthog/mcp/_event_types.py            |   1 +
 posthog/mcp/_instrument_fastmcp.py     |   4 +
 posthog/mcp/_instrument_lowlevel.py    |  89 +++++-
 posthog/mcp/_instrument_v2.py          |  16 ++
 posthog/mcp/_instrumentation.py        |  59 ++++
 posthog/mcp/_posthog_events.py         |   9 +-
 posthog/mcp/_sanitization.py           |  11 +-
 posthog/mcp/_truncation.py             |  19 +-
 posthog/mcp/feedback.py                |  14 +-
 posthog/mcp/posthog_mcp.py             |   4 +-
 posthog/test/mcp/test_feedback.py      |   4 +-
 posthog/test/mcp/test_pipeline.py      |   2 +-
 posthog/test/mcp/test_posthog_mcp.py   |  14 +
 posthog/test/mcp/test_truncation.py    |  12 +-
 posthog/test/mcp/test_unknown_tool.py  | 369 +++++++++++++++++++++++++
 17 files changed, 623 insertions(+), 37 deletions(-)
 create mode 100644 .sampo/changesets/mcp-v1-spec-align.md
 create mode 100644 posthog/test/mcp/test_unknown_tool.py

diff --git a/.sampo/changesets/mcp-v1-spec-align.md b/.sampo/changesets/mcp-v1-spec-align.md
new file mode 100644
index 000000000..718b5a7a0
--- /dev/null
+++ b/.sampo/changesets/mcp-v1-spec-align.md
@@ -0,0 +1,10 @@
+---
+pypi/posthog: minor
+---
+
+MCP analytics now matches the cross-SDK MCP spec ahead of 1.0:
+
+- `instrument()` sends `$mcp_unknown_tool` instead of a failed `$mcp_tool_call` and `$exception` when a `tools/call` names a tool your server never registered. Insights that count failed tool calls stop counting these. A call naming no tool sends nothing. A raw low-level server has no registry the SDK can read, so a failed call there stays a failed tool call.
+- FastMCP's stock logging, timing, error-handling, and similar middleware no longer turns off `llm_model` injection on standalone `fastmcp.FastMCP`.
+- Manual capture without a `session_id` now sends a fresh `ses_` session id and uses it as the `distinct_id`, instead of no `$session_id` and an `anonymous` person.
+- Truncated string properties now fit their limit with the `...` marker included, so `$mcp_tool_name` and other names stop at 256 characters instead of 259.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index 58f177233..464036161 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -191,8 +191,10 @@ On MCP SDK 1.x, standalone FastMCP application middleware can replace or reroute
 When it overrides a listing or dispatch hook, PostHog does not inject `llm_model`: a fresh
 replica cannot safely distinguish that field from a replacement tool's own argument.
 Client metadata capture remains enabled. This also applies to pass-through logging or
-authorization middleware with those hooks; argument-based model capture is skipped so an
-application-owned value cannot be mistaken for analytics. No additional catalog lookup runs
+authorization middleware of your own with those hooks; argument-based model capture is skipped
+so an application-owned value cannot be mistaken for analytics. FastMCP's stock middleware,
+such as `LoggingMiddleware`, `TimingMiddleware`, and `ErrorHandlingMiddleware`, never reroutes a
+tool and does not count; its tool-injection middleware does. No additional catalog lookup runs
 during a tool call.
 
 For a custom dispatcher, `PostHogMCP` enables model capture and conversation correlation
@@ -339,6 +341,23 @@ call = posthog.prepare_tool_call(
 )
 ```
 
+## Calls to tools your server does not have
+
+A `tools/call` naming a tool your server never registered is not a tool call.
+`instrument()` sends `$mcp_unknown_tool` with the requested name as
+`$mcp_tool_name`, and no `$mcp_tool_call` or `$exception`. The agent gets the
+same error as before. A call naming no tool sends nothing.
+
+The SDK asks the tool registry only after the call fails, and records a failed
+tool call whenever the registry can't rule the tool out:
+
+- A disabled tool, or a tool called with invalid arguments, still exists.
+- A raw low-level server has no registry the SDK can read.
+- On standalone `fastmcp.FastMCP`, middleware of your own that overrides a
+  listing or dispatch hook can serve tools the registry lacks.
+- On standalone `fastmcp.FastMCP` 3 and later, a mounted server, proxy, or
+  other provider hides its disabled tools.
+
 ## Virtual tools on a paginated `tools/list`
 
 `instrument()` advertises up to two tools of its own: `get_more_tools`
diff --git a/posthog/mcp/_event_types.py b/posthog/mcp/_event_types.py
index 7392f90a9..005d08457 100644
--- a/posthog/mcp/_event_types.py
+++ b/posthog/mcp/_event_types.py
@@ -23,3 +23,4 @@ class MCPAnalyticsEventType:
     MCP_RESOURCES_READ = "mcp:resources/read"
     MCP_TOOLS_CALL = "mcp:tools/call"
     MCP_TOOLS_LIST = "mcp:tools/list"
+    MCP_UNKNOWN_TOOL = "mcp:unknown_tool"
diff --git a/posthog/mcp/_instrument_fastmcp.py b/posthog/mcp/_instrument_fastmcp.py
index 78bd1324f..366060141 100644
--- a/posthog/mcp/_instrument_fastmcp.py
+++ b/posthog/mcp/_instrument_fastmcp.py
@@ -167,6 +167,10 @@ async def wrapped(
                 name, call_arguments, context=context, convert_result=convert_result
             )
         except Exception as error:
+            if await lifecycle.record_if_unknown_tool(
+                _name_owned_by_real_tool(server, name)
+            ):
+                raise
             # The minted prompt-back was never delivered to the agent — don't stamp
             # an orphan conversation_id it can't echo (an agent-supplied id is kept).
             await lifecycle.record_error(error, (time.monotonic() - start) * 1000)
diff --git a/posthog/mcp/_instrument_lowlevel.py b/posthog/mcp/_instrument_lowlevel.py
index 00bd4ef4d..3d84988a4 100644
--- a/posthog/mcp/_instrument_lowlevel.py
+++ b/posthog/mcp/_instrument_lowlevel.py
@@ -15,10 +15,11 @@
 from __future__ import annotations
 
 import functools
+import importlib
 import inspect
 import time
 from functools import lru_cache
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple, Type
 
 import mcp.types as mcp_types
 
@@ -36,6 +37,7 @@
     copy_tools_list_result,
     extract_tools,
     is_first_listing_page,
+    is_tool_result_error,
     mutate_tool_schema,
     prepare_request,
     raw_listing_owns_tool_name,
@@ -282,6 +284,10 @@ async def handler(req: Any) -> Any:
         try:
             result = await original(req)
         except Exception as error:
+            if await lifecycle.record_if_unknown_tool(
+                await registered_tool_exists(high_level, name)
+            ):
+                raise
             # The @server.call_tool() decorator converts raises into
             # CallToolResult(isError=True), but a handler wired straight into
             # request_handlers can raise — capture before re-raising so the failed
@@ -333,6 +339,12 @@ async def handler(req: Any) -> Any:
                     else call_result
                 )
 
+        if is_tool_result_error(call_result) and await lifecycle.record_if_unknown_tool(
+            await registered_tool_exists(high_level, name),
+            conversation_id_delivered=delivered,
+        ):
+            return result
+
         await lifecycle.record_result(
             call_result,
             duration_ms,
@@ -573,7 +585,7 @@ async def _name_owned_by_real_tool(
 
 
 @lru_cache(maxsize=1)
-def _tool_lookup_not_found_errors() -> Tuple[type, ...]:
+def _tool_lookup_not_found_errors() -> Tuple[Type[BaseException], ...]:
     """The fastmcp exceptions that mean "no live tool by that name" -- an answer.
     Anything else out of ``get_tool`` is the lookup itself failing. Empty when
     fastmcp is absent or has moved them, which makes every failure delegate:
@@ -793,13 +805,82 @@ def _dispatch_can_differ(server: Any) -> bool:
     )
 
 
+# Stock fastmcp middleware that observes, times, retries, throttles, denies,
+# caches, or trims a call to the tool it names, and never provides, renames, or
+# reroutes one. The tool-injection family is left out on purpose.
+_STOCK_DISPATCH_PRESERVING_MIDDLEWARE = (
+    ("logging", "LoggingMiddleware"),
+    ("logging", "StructuredLoggingMiddleware"),
+    ("timing", "TimingMiddleware"),
+    ("timing", "DetailedTimingMiddleware"),
+    ("error_handling", "ErrorHandlingMiddleware"),
+    ("error_handling", "RetryMiddleware"),
+    ("rate_limiting", "RateLimitingMiddleware"),
+    ("rate_limiting", "SlidingWindowRateLimitingMiddleware"),
+    ("ping", "PingMiddleware"),
+    ("authorization", "AuthMiddleware"),
+    ("caching", "ResponseCachingMiddleware"),
+    ("response_limiting", "ResponseLimitingMiddleware"),
+)
+
+
 @functools.lru_cache(maxsize=1)
 def _builtin_middleware_types() -> tuple:
     """The middleware a bare ``FastMCP()`` installs on its own, probed rather
-    than named so a new built-in in a later release is still recognised."""
+    than named so a new built-in in a later release is still recognised, plus
+    the stock middleware above that this fastmcp release ships."""
     from fastmcp import FastMCP
 
-    return tuple(type(middleware) for middleware in FastMCP("posthog-probe").middleware)
+    stock = []
+    for module, name in _STOCK_DISPATCH_PRESERVING_MIDDLEWARE:
+        try:
+            stock.append(
+                getattr(
+                    importlib.import_module(f"fastmcp.server.middleware.{module}"), name
+                )
+            )
+        except (ImportError, AttributeError):
+            continue
+    return tuple(
+        type(middleware) for middleware in FastMCP("posthog-probe").middleware
+    ) + tuple(stock)
+
+
+async def registered_tool_exists(server: Any, name: str) -> Optional[bool]:
+    """Whether jlowin's FastMCP registers ``name``, enabled or not, asked after a
+    failed call to tell an unknown tool from a failed one. A disabled tool still
+    exists: calling it is a failed call. ``None`` when nothing authoritative can
+    say: no registry (a raw low-level server, whose listing may hide tools its
+    dispatcher serves), middleware that can serve tools the registry lacks, or a
+    mounted server or other provider, which hides its disabled tools."""
+    if server is None or _dispatch_can_differ(server):
+        return None
+    try:
+        from fastmcp import FastMCP
+
+        # From 3.x, get_tool hides a disabled tool; the providers still hold it.
+        found = (
+            await server.get_tool(name) is not None
+            or await super(FastMCP, server).get_tool(name) is not None
+        )
+    except _tool_lookup_not_found_errors():
+        found = False
+    except Exception as err:  # noqa: BLE001 - analytics must not break the call
+        log(f"PostHog MCP: could not look up tool {name!r} - {err}")
+        return None
+    if found:
+        return True
+    return None if _serves_other_providers(server) else False
+
+
+def _serves_other_providers(server: Any) -> bool:
+    """Whether a FastMCP server serves tools from anywhere but its own
+    registry: a mounted server, a proxy, or a custom provider. FastMCP 2.x
+    keeps mounts in ``_mounted_servers``; 3.x lists them in ``providers``."""
+    if getattr(server, "_mounted_servers", None):
+        return True
+    local = getattr(server, "_local_provider", None)
+    return any(provider is not local for provider in getattr(server, "providers", ()))
 
 
 def _reference_chain(schema: Dict[str, Any]) -> Optional[List[Dict[str, Any]]]:
diff --git a/posthog/mcp/_instrument_v2.py b/posthog/mcp/_instrument_v2.py
index 58d45f778..b7d597789 100644
--- a/posthog/mcp/_instrument_v2.py
+++ b/posthog/mcp/_instrument_v2.py
@@ -53,6 +53,7 @@
     _to_jsonable,
     copy_tools_list_result,
     is_first_listing_page,
+    is_tool_result_error,
     mutate_tool_schema,
     params_to_request_dict,
     prepare_request,
@@ -66,6 +67,7 @@
     start_tools_list_lifecycle,
     warn_ownership_lookup_failed,
 )
+from ._instrument_lowlevel import registered_tool_exists
 from ._internal import MCPAnalyticsData
 from ._model_parameters import (
     can_inject_model_parameter,
@@ -450,6 +452,10 @@ async def wrapped(
                 name, call_arguments, context=context, convert_result=convert_result
             )
         except Exception as error:
+            if await lifecycle.record_if_unknown_tool(
+                _name_owned_by_real_tool_v2(server, name)
+            ):
+                raise
             # The outer MCPServer layer converts the raise after this seam; no
             # freshly minted handle could have been delivered yet.
             await lifecycle.record_error(error, (time.monotonic() - start) * 1000)
@@ -669,6 +675,10 @@ async def handler(ctx: Any, params: Any) -> Any:
         try:
             result = await original(ctx, params)
         except Exception as error:
+            if await lifecycle.record_if_unknown_tool(
+                await registered_tool_exists(standalone, name)
+            ):
+                raise
             # Raw v2 handlers raise through to JSON-RPC errors; no freshly minted
             # handle could have been delivered yet.
             await lifecycle.record_error(error, (time.monotonic() - start) * 1000)
@@ -685,6 +695,12 @@ async def handler(ctx: Any, params: Any) -> Any:
                 lifecycle.minted_conversation_id,
             )
 
+        if is_tool_result_error(result) and await lifecycle.record_if_unknown_tool(
+            await registered_tool_exists(standalone, name),
+            conversation_id_delivered=delivered,
+        ):
+            return result
+
         await lifecycle.record_result(
             result, duration_ms, conversation_id_delivered=delivered
         )
diff --git a/posthog/mcp/_instrumentation.py b/posthog/mcp/_instrumentation.py
index ae8d7b30b..9b1db44c7 100644
--- a/posthog/mcp/_instrumentation.py
+++ b/posthog/mcp/_instrumentation.py
@@ -615,6 +615,32 @@ async def record_feedback(self, *, conversation_id_delivered: bool = False) -> s
         )
         return await handle_feedback(report, self.feedback_options)
 
+    async def record_if_unknown_tool(
+        self, tool_exists: Optional[bool], *, conversation_id_delivered: bool = False
+    ) -> bool:
+        """Record the failed call as ``$mcp_unknown_tool`` when ``tool_exists``
+        proves the server has no tool by that name, and say whether the call is
+        settled that way. A call naming no tool is settled with no event. The
+        adapter then re-raises or returns its response."""
+        if not self.name:
+            return True
+        if tool_exists is not False:
+            return False
+        conversation_id = self._anchored_conversation_id(conversation_id_delivered)
+        session_id = await self.prepare_session(conversation_id)
+        await record_unknown_tool(
+            self.data,
+            session_id,
+            conversation_id=conversation_id,
+            name=self.name,
+            arguments=self.arguments,
+            client_name=self.client_name,
+            client_version=self.client_version,
+            protocol_version=self.protocol_version,
+            extra=self.extra,
+        )
+        return True
+
     async def record_error(self, error: Any, duration_ms: float) -> None:
         # A freshly minted handle cannot anchor or be captured when dispatch
         # raised: no adapter had an opportunity to deliver it to the agent.
@@ -1374,6 +1400,39 @@ async def record_missing_capability(
         log(f"record_missing_capability failed (event dropped): {err}")
 
 
+async def record_unknown_tool(
+    data: MCPAnalyticsData,
+    session_id: str,
+    *,
+    conversation_id: Optional[str],
+    name: str,
+    arguments: Optional[Dict[str, Any]],
+    client_name: Optional[str],
+    client_version: Optional[str],
+    protocol_version: Optional[str],
+    extra: Optional[Dict[str, Any]],
+) -> None:
+    """Record a call naming a tool the server never registered as
+    ``$mcp_unknown_tool``. It is not a tool call, so it carries no outcome."""
+    try:
+        event: Dict[str, Any] = {
+            "event_type": MCPAnalyticsEventType.MCP_UNKNOWN_TOOL,
+            "session_id": session_id,
+            "conversation_id": conversation_id,
+            "resource_name": name,
+            "client_name": client_name,
+            "client_version": client_version,
+            "protocol_version": protocol_version,
+        }
+        await _apply_event_properties(
+            data, event, build_tool_call_request(name, arguments), extra
+        )
+        stamp_transport_identity(event, extra)
+        fire_and_forget(capture_event(data, event), data)
+    except Exception as err:  # noqa: BLE001 - isolate analytics from the tool path
+        log(f"record_unknown_tool failed (event dropped): {err}")
+
+
 async def record_feedback(
     data: MCPAnalyticsData,
     session_id: str,
diff --git a/posthog/mcp/_posthog_events.py b/posthog/mcp/_posthog_events.py
index 51fc5ff75..f7b58f0e7 100644
--- a/posthog/mcp/_posthog_events.py
+++ b/posthog/mcp/_posthog_events.py
@@ -29,6 +29,7 @@
     MCPAnalyticsEventType.MCP_RESOURCES_READ: PostHogMCPAnalyticsEvent.RESOURCE_READ,
     MCPAnalyticsEventType.MCP_TOOLS_CALL: PostHogMCPAnalyticsEvent.TOOL_CALL,
     MCPAnalyticsEventType.MCP_TOOLS_LIST: PostHogMCPAnalyticsEvent.TOOLS_LIST,
+    MCPAnalyticsEventType.MCP_UNKNOWN_TOOL: "$mcp_unknown_tool",
 }
 
 _P = PostHogMCPAnalyticsProperty
@@ -112,8 +113,12 @@ def _is_tool_call(event: Event) -> bool:
 
 def _add_common_properties(event: Event, properties: Dict[str, Any]) -> None:
     if event.get("resource_name"):
-        properties[_P.RESOURCE_NAME] = event["resource_name"]
-        if _is_tool_call(event):
+        is_unknown_tool = (
+            event.get("event_type") == MCPAnalyticsEventType.MCP_UNKNOWN_TOOL
+        )
+        if not is_unknown_tool:
+            properties[_P.RESOURCE_NAME] = event["resource_name"]
+        if is_unknown_tool or _is_tool_call(event):
             properties[_P.TOOL_NAME] = event["resource_name"]
     if event.get("tool_description") and _is_tool_call(event):
         properties[_P.TOOL_DESCRIPTION] = event["tool_description"]
diff --git a/posthog/mcp/_sanitization.py b/posthog/mcp/_sanitization.py
index b14f4796d..426d2d29f 100644
--- a/posthog/mcp/_sanitization.py
+++ b/posthog/mcp/_sanitization.py
@@ -14,6 +14,8 @@
 from typing import Any, Dict, List, Optional, Set, Tuple
 from urllib.parse import SplitResult, parse_qsl, urlencode, urlsplit, urlunsplit
 
+from ._event_types import MCPAnalyticsEventType
+
 # SDK-injected arguments stripped from captured $mcp_parameters (they surface as
 # dedicated properties: $mcp_intent and $mcp_conversation_id).
 _INJECTED_ARGUMENT_NAMES = ("context", "conversation_id")
@@ -628,8 +630,15 @@ def sanitize_event(event: Dict[str, Any]) -> Dict[str, Any]:
     if result.get("parameters") is not None:
         result["parameters"] = sanitize_captured_value(result["parameters"])
 
+    # An unknown tool's name is whatever the agent sent, not one of the
+    # server's identifiers, so it gets the free-text pass.
     if result.get("resource_name") is not None:
-        result["resource_name"] = _sanitize_resource_name(result["resource_name"])
+        sanitize_name = (
+            sanitize_free_text
+            if result.get("event_type") == MCPAnalyticsEventType.MCP_UNKNOWN_TOOL
+            else _sanitize_resource_name
+        )
+        result["resource_name"] = sanitize_name(result["resource_name"])
 
     # The intent comes straight from an agent-narrated `context` string, so it
     # can contain a secret the LLM read aloud or personal data it narrated about
diff --git a/posthog/mcp/_truncation.py b/posthog/mcp/_truncation.py
index 674241a6c..382c64639 100644
--- a/posthog/mcp/_truncation.py
+++ b/posthog/mcp/_truncation.py
@@ -85,9 +85,7 @@ def _visit(
                 return "[Infinity]" if value > 0 else "[-Infinity]"
         return value
     if isinstance(value, str):
-        if len(value) > max_string_length:
-            return value[:max_string_length] + _TRUNCATION_SUFFIX
-        return value
+        return truncate_text(value, max_string_length)
     if isinstance(value, datetime):
         return value.isoformat()
     if callable(value):
@@ -161,12 +159,18 @@ def _visit_object(
 # --- field-level helpers -----------------------------------------------------
 
 
+def truncate_text(value: str, max_length: int) -> str:
+    """``value`` cut to at most ``max_length`` characters, the truncation marker
+    included, keeping its start."""
+    if len(value) <= max_length:
+        return value
+    return value[: max_length - len(_TRUNCATION_SUFFIX)] + _TRUNCATION_SUFFIX
+
+
 def _truncate_string(value: Optional[str], max_length: int) -> Optional[str]:
     if not isinstance(value, str):
         return value
-    if len(value) <= max_length:
-        return value
-    return value[:max_length] + _TRUNCATION_SUFFIX
+    return truncate_text(value, max_length)
 
 
 def _truncate_stack_frames(frames: Optional[List[Any]]) -> Optional[List[Any]]:
@@ -214,8 +218,7 @@ def _truncate_response_content(response: Any) -> Any:
                 new_content.append(
                     {
                         **block,
-                        "text": block["text"][:_MAX_CONTENT_TEXT_LENGTH]
-                        + _TRUNCATION_SUFFIX,
+                        "text": truncate_text(block["text"], _MAX_CONTENT_TEXT_LENGTH),
                     }
                 )
             else:
diff --git a/posthog/mcp/feedback.py b/posthog/mcp/feedback.py
index 5d1bc1d08..5cb732b6c 100644
--- a/posthog/mcp/feedback.py
+++ b/posthog/mcp/feedback.py
@@ -11,6 +11,7 @@
 
 from ._internal import _maybe_await
 from ._sanitization import sanitize_free_text, sanitize_free_text_value
+from ._truncation import truncate_text
 from .constants import PostHogMCPAnalyticsProperty
 from .logger import log
 from .tools import VIRTUAL_TOOL_HINTS
@@ -26,7 +27,6 @@
 # Free-text fields are agent-narrated, like `$mcp_intent`; bound them the same way.
 _MAX_FEEDBACK_TEXT_LENGTH = 2048
 _MAX_FEEDBACK_TOOL_NAME_LENGTH = 256
-_TRUNCATION_SUFFIX = "..."
 
 _DEFAULT_FEEDBACK_DESCRIPTION = (
     "Send feedback about this server to its developers: a capability you needed that no tool "
@@ -247,10 +247,6 @@ def build_feedback_intent(report: FeedbackReport) -> str:
     return "\n\n".join(part for part in (report.summary, report.details) if part)
 
 
-def _truncate_feedback_text(value: str, max_length: int) -> str:
-    return value[:max_length] + _TRUNCATION_SUFFIX if len(value) > max_length else value
-
-
 def _capture_free_text(value: str) -> str:
     """Agent-narrated free text can contain a secret the LLM read aloud or personal
     data it narrated, so it gets exactly the ``$mcp_intent`` pass
@@ -258,7 +254,7 @@ def _capture_free_text(value: str) -> str:
     load-bearing, the URL rewrite would percent-encode the ``@`` the email pattern
     anchors on), then a length bound. The event pipeline does not process
     ``event["properties"]``, so this happens here."""
-    return _truncate_feedback_text(sanitize_free_text(value), _MAX_FEEDBACK_TEXT_LENGTH)
+    return truncate_text(sanitize_free_text(value), _MAX_FEEDBACK_TEXT_LENGTH)
 
 
 def _capture_extra_value(value: Any) -> Any:
@@ -268,11 +264,11 @@ def _capture_extra_value(value: Any) -> Any:
     JSON-stringified and everything is bounded. Unserializable values are dropped."""
     sanitized = sanitize_free_text_value(value)
     if isinstance(sanitized, str):
-        return _truncate_feedback_text(sanitized, _MAX_FEEDBACK_TEXT_LENGTH)
+        return truncate_text(sanitized, _MAX_FEEDBACK_TEXT_LENGTH)
     if sanitized is None or isinstance(sanitized, (bool, int, float)):
         return sanitized
     try:
-        return _truncate_feedback_text(json.dumps(sanitized), _MAX_FEEDBACK_TEXT_LENGTH)
+        return truncate_text(json.dumps(sanitized), _MAX_FEEDBACK_TEXT_LENGTH)
     except Exception:  # noqa: BLE001 - capture must never raise into the tool path
         return None
 
@@ -305,7 +301,7 @@ def build_feedback_event_properties(report: FeedbackReport) -> JsonRecord:
         # Nominally an identifier, but the schema can't stop an agent from
         # writing prose into it — so it gets the same free-text pass as the
         # other fields.
-        properties[PostHogMCPAnalyticsProperty.FEEDBACK_TOOL] = _truncate_feedback_text(
+        properties[PostHogMCPAnalyticsProperty.FEEDBACK_TOOL] = truncate_text(
             sanitize_free_text(report.tool_name),
             _MAX_FEEDBACK_TOOL_NAME_LENGTH,
         )
diff --git a/posthog/mcp/posthog_mcp.py b/posthog/mcp/posthog_mcp.py
index 69951eade..2e1c4d3e5 100644
--- a/posthog/mcp/posthog_mcp.py
+++ b/posthog/mcp/posthog_mcp.py
@@ -70,7 +70,7 @@
     resolve_collect_feedback_options,
     resolve_send_feedback_tool_name,
 )
-from .session import derive_session_id_from_conversation
+from .session import derive_session_id_from_conversation, new_session_id
 from .tools import build_report_missing_descriptor
 from .types import (
     CollectFeedbackOptions,
@@ -712,7 +712,7 @@ def _base_event(
     ) -> Dict[str, Any]:
         event: Dict[str, Any] = {
             "event_type": event_type,
-            "session_id": session_id,
+            "session_id": session_id or new_session_id(),
             "conversation_id": conversation_id,
             "timestamp": timestamp or datetime.now(timezone.utc),
             "properties": properties,
diff --git a/posthog/test/mcp/test_feedback.py b/posthog/test/mcp/test_feedback.py
index b45721c38..5110a0d60 100644
--- a/posthog/test/mcp/test_feedback.py
+++ b/posthog/test/mcp/test_feedback.py
@@ -237,9 +237,9 @@ def test_properties_bound_free_text_and_tool_name():
         {"feedback_type": "issue", "summary": "s" * 5000, "tool_name": "t" * 500}
     )
     props = build_feedback_event_properties(report)
-    assert len(props["$mcp_feedback_summary"]) == 2048 + 3
+    assert len(props["$mcp_feedback_summary"]) == 2048
     assert props["$mcp_feedback_summary"].endswith("...")
-    assert len(props["$mcp_feedback_tool"]) == 256 + 3
+    assert len(props["$mcp_feedback_tool"]) == 256
 
 
 def test_properties_capture_declared_extras_only():
diff --git a/posthog/test/mcp/test_pipeline.py b/posthog/test/mcp/test_pipeline.py
index 6a4dda12f..ea7457023 100644
--- a/posthog/test/mcp/test_pipeline.py
+++ b/posthog/test/mcp/test_pipeline.py
@@ -821,7 +821,7 @@ def test_sanitize_event_passes_through_non_string_intent():
 def test_normalize_caps_long_strings():
     out = normalize("x" * 40000)
     assert out.endswith("...")
-    assert len(out) == 32_768 + 3
+    assert len(out) == 32_768
 
 
 def test_normalize_detects_cycles():
diff --git a/posthog/test/mcp/test_posthog_mcp.py b/posthog/test/mcp/test_posthog_mcp.py
index 51bbb679b..fb2e69961 100644
--- a/posthog/test/mcp/test_posthog_mcp.py
+++ b/posthog/test/mcp/test_posthog_mcp.py
@@ -783,3 +783,17 @@ async def test_capture_tool_call_records_prepared_conversation_and_session():
     props = _events(captured, "$mcp_tool_call")[0]["properties"]
     assert props["$mcp_conversation_id"] == prepared.conversation_id
     assert props["$session_id"] == prepared.session_id
+
+
+def test_capture_without_a_session_gets_a_fresh_one_per_call():
+    client, captured = make_client()
+
+    client.capture_tool_call("t")
+    client.capture_tool_call("t")
+    client.flush()
+
+    first, second = captured
+    session = first["properties"]["$session_id"]
+    assert session.startswith("ses_")
+    assert first["distinct_id"] == session
+    assert second["properties"]["$session_id"] != session
diff --git a/posthog/test/mcp/test_truncation.py b/posthog/test/mcp/test_truncation.py
index a0752c6c4..a3d47be49 100644
--- a/posthog/test/mcp/test_truncation.py
+++ b/posthog/test/mcp/test_truncation.py
@@ -20,7 +20,7 @@
 
 def test_normalize_caps_long_strings():
     out = normalize("x" * (MAX_STRING_LENGTH + 100))
-    assert out.endswith("...") and len(out) == MAX_STRING_LENGTH + 3
+    assert out.endswith("...") and len(out) == MAX_STRING_LENGTH
 
 
 def test_normalize_keeps_bool_distinct_from_int():
@@ -102,9 +102,9 @@ def test_truncate_event_caps_metadata_fields():
             "llm_model": "m" * 500,
         }
     )
-    assert len(out["user_intent"]) == 2048 + 3
-    assert len(out["resource_name"]) == 256 + 3
-    assert len(out["llm_model"]) == 256 + 3
+    assert len(out["user_intent"]) == 2048
+    assert len(out["resource_name"]) == 256
+    assert len(out["llm_model"]) == 256
 
 
 def test_truncate_event_caps_exception_value_and_frames():
@@ -119,7 +119,7 @@ def test_truncate_event_caps_exception_value_and_frames():
         }
     )
     exc = out["error"]["$exception_list"][0]
-    assert len(exc["value"]) == 2048 + 3
+    assert len(exc["value"]) == 2048
     assert exc["stacktrace"]["frames"] == frames[:25] + frames[-25:]
 
 
@@ -127,7 +127,7 @@ def test_truncate_event_caps_response_text_block():
     out = truncate_event(
         {"response": {"content": [{"type": "text", "text": "t" * 40000}]}}
     )
-    assert len(out["response"]["content"][0]["text"]) == 32_768 + 3
+    assert len(out["response"]["content"][0]["text"]) == 32_768
 
 
 # --- size-targeted budget ----------------------------------------------------
diff --git a/posthog/test/mcp/test_unknown_tool.py b/posthog/test/mcp/test_unknown_tool.py
new file mode 100644
index 000000000..8d1396d26
--- /dev/null
+++ b/posthog/test/mcp/test_unknown_tool.py
@@ -0,0 +1,369 @@
+"""``$mcp_unknown_tool``: a call naming a tool the server never registered is
+not a tool call. Runs under both MCP SDK majors over an in-process client, so
+the response compared against an uninstrumented twin is the one an agent gets."""
+
+import importlib
+import importlib.util
+import json
+from contextlib import asynccontextmanager
+
+import mcp.types as mcp_types
+import pytest
+
+from posthog.mcp import instrument
+from posthog.mcp.types import MCPAnalyticsOptions
+from posthog.test.mcp._helpers import (
+    MCP_MAJOR,
+    FakeClient,
+    events_named,
+    flush_background,
+)
+
+_needs_standalone = pytest.mark.skipif(
+    importlib.util.find_spec("fastmcp") is None, reason="standalone fastmcp"
+)
+
+
+def _fastmcp_can_disable() -> bool:
+    try:
+        from fastmcp import FastMCP
+    except ImportError:
+        return False
+    return hasattr(FastMCP, "disable")
+
+
+_needs_server_disable = pytest.mark.skipif(
+    not _fastmcp_can_disable(), reason="FastMCP.disable and providers, fastmcp 3+"
+)
+
+
+def _high_level():
+    if MCP_MAJOR >= 2:
+        from mcp.server.mcpserver import MCPServer as HighLevel
+    else:
+        from mcp.server.fastmcp import FastMCP as HighLevel
+    server = HighLevel("unknown-tool")
+
+    @server.tool()
+    def search_docs(query: str) -> str:
+        return f"found {query}"
+
+    return server
+
+
+def _standalone(*middleware):
+    """``middleware`` names stock fastmcp middleware as ``"<module>.<class>"``
+    under ``fastmcp.server.middleware``."""
+    from fastmcp import FastMCP
+
+    server = FastMCP("unknown-tool")
+
+    @server.tool
+    def search_docs(query: str) -> str:
+        return f"found {query}"
+
+    for path in middleware:
+        module, name = path.rsplit(".", 1)
+        stock = importlib.import_module(f"fastmcp.server.middleware.{module}")
+        server.add_middleware(getattr(stock, name)())
+    return server
+
+
+def _standalone_with_disabled_tool():
+    server = _standalone()
+
+    @server.tool
+    def retired(query: str) -> str:
+        return query
+
+    server.disable(names={"retired"})
+    return server
+
+
+def _standalone_with_application_middleware():
+    from fastmcp.server.middleware.logging import LoggingMiddleware
+
+    class AuditMiddleware(LoggingMiddleware):
+        async def on_call_tool(self, context, call_next):
+            return await call_next(context)
+
+    server = _standalone()
+    server.add_middleware(AuditMiddleware())
+    return server
+
+
+def _mounted():
+    """A parent serving a sub-server's tools under the ``ns`` namespace, one
+    of them disabled on the sub-server."""
+    from fastmcp import FastMCP
+
+    sub = FastMCP("sub")
+
+    @sub.tool
+    def retired(query: str) -> str:
+        return query
+
+    sub.disable(names={"retired"})
+    parent = _standalone()
+    parent.mount(sub, namespace="ns")
+    return parent
+
+
+def _with_mounted_server():
+    """A parent serving a sub-server's tools under the ``ns`` prefix, on every
+    fastmcp major (2.x spells the argument ``prefix``, 3.x ``namespace``)."""
+    from fastmcp import FastMCP
+
+    sub = FastMCP("sub")
+
+    @sub.tool
+    def lookup(query: str) -> str:
+        return query
+
+    parent = _standalone()
+    try:
+        parent.mount(sub, namespace="ns")
+    except TypeError:
+        parent.mount(sub, prefix="ns")
+    return parent
+
+
+def _raw(listed):
+    """A raw low-level server whose own dispatcher rejects names it does not
+    know and advertises ``listed`` on tools/list."""
+    from mcp.server.lowlevel import Server
+
+    schema = {"type": "object", "properties": {"query": {"type": "string"}}}
+    listing = mcp_types.ListToolsResult(
+        tools=[
+            mcp_types.Tool(
+                name=name,
+                **{"input_schema" if MCP_MAJOR >= 2 else "inputSchema": schema},
+            )
+            for name in listed
+        ]
+    )
+
+    def reply(name):
+        if name not in listed:
+            raise ValueError(f"Unknown tool: {name}")
+        return [mcp_types.TextContent(type="text", text="ok")]
+
+    if MCP_MAJOR >= 2:
+
+        async def on_call_tool(ctx, params):
+            return mcp_types.CallToolResult(content=reply(params.name))
+
+        async def on_list_tools(ctx, params):
+            return listing
+
+        return Server(
+            "unknown-tool", on_call_tool=on_call_tool, on_list_tools=on_list_tools
+        )
+
+    server = Server("unknown-tool")
+
+    @server.call_tool()
+    async def call_tool(name, arguments):
+        return reply(name)
+
+    async def list_tools(req):
+        return mcp_types.ServerResult(listing)
+
+    server.request_handlers[mcp_types.ListToolsRequest] = list_tools
+    return server
+
+
+@asynccontextmanager
+async def _connected(server):
+    if type(server).__module__.startswith("fastmcp"):
+        from fastmcp import Client
+
+        async with Client(server) as client:
+            yield lambda name, args: client.call_tool(name, args, raise_on_error=False)
+    elif MCP_MAJOR >= 2:
+        from mcp import Client
+
+        async with Client(server) as client:
+            yield client.call_tool
+    else:
+        from mcp.shared.memory import create_connected_server_and_client_session
+
+        async with create_connected_server_and_client_session(server) as session:
+            yield session.call_tool
+
+
+async def _response(server, name, arguments):
+    async with _connected(server) as call:
+        try:
+            result = await call(name, arguments)
+        except Exception as error:  # noqa: BLE001 - the error is the response
+            return type(error).__name__, str(error)
+    is_error = result.is_error if hasattr(result, "is_error") else result.isError
+    return is_error, [getattr(block, "text", None) for block in result.content]
+
+
+@pytest.mark.parametrize(
+    "build",
+    [
+        pytest.param(_high_level, id="high-level"),
+        pytest.param(_standalone, id="standalone-fastmcp", marks=_needs_standalone),
+        *(
+            pytest.param(
+                lambda path=path: _standalone(path),
+                id=f"standalone-fastmcp-with-{path.split('.')[0]}-middleware",
+                marks=_needs_standalone,
+            )
+            for path in (
+                "logging.LoggingMiddleware",
+                "timing.TimingMiddleware",
+                "error_handling.ErrorHandlingMiddleware",
+            )
+        ),
+    ],
+)
+async def test_a_call_to_a_tool_that_does_not_exist_is_recorded_as_unknown(build):
+    expected = await _response(build(), "no_such_tool", {})
+    client = FakeClient()
+    server = build()
+    instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
+
+    assert await _response(server, "no_such_tool", {}) == expected
+    await flush_background()
+
+    [unknown] = events_named(client, "$mcp_unknown_tool")
+    assert unknown["properties"]["$mcp_tool_name"] == "no_such_tool"
+    assert unknown["properties"]["$session_id"]
+    assert events_named(client, "$mcp_tool_call") == []
+    assert events_named(client, "$exception") == []
+
+
+@pytest.mark.parametrize(
+    "build, name, arguments",
+    [
+        pytest.param(_high_level, "search_docs", {}, id="invalid-arguments"),
+        pytest.param(
+            _standalone_with_disabled_tool,
+            "retired",
+            {"query": "q"},
+            id="disabled-standalone-tool",
+            marks=_needs_server_disable,
+        ),
+        pytest.param(
+            _mounted,
+            "ns_retired",
+            {"query": "q"},
+            id="disabled-tool-on-mounted-server",
+            marks=_needs_server_disable,
+        ),
+        pytest.param(
+            _mounted,
+            "ns_no_such_tool",
+            {},
+            id="server-with-mounted-provider",
+            marks=_needs_server_disable,
+        ),
+        pytest.param(
+            _with_mounted_server,
+            "ns_no_such_tool",
+            {},
+            id="server-with-mounted-server",
+            marks=_needs_standalone,
+        ),
+        pytest.param(
+            _standalone_with_application_middleware,
+            "no_such_tool",
+            {},
+            id="standalone-with-application-middleware",
+            marks=_needs_standalone,
+        ),
+        pytest.param(
+            lambda: _raw(["search_docs"]),
+            "no_such_tool",
+            {},
+            id="raw-low-level-unknown-name",
+        ),
+    ],
+)
+async def test_a_call_the_sdk_cannot_rule_out_is_a_failed_tool_call(
+    build, name, arguments
+):
+    expected = await _response(build(), name, arguments)
+    client = FakeClient()
+    server = build()
+    instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
+
+    assert await _response(server, name, arguments) == expected
+    await flush_background()
+
+    [call] = events_named(client, "$mcp_tool_call")
+    assert call["properties"]["$mcp_tool_name"] == name
+    assert call["properties"]["$mcp_is_error"] is True
+    assert events_named(client, "$mcp_unknown_tool") == []
+
+
+_SHAPES = [
+    pytest.param(_high_level, id="high-level"),
+    pytest.param(_standalone, id="standalone-fastmcp", marks=_needs_standalone),
+]
+
+
+@pytest.mark.parametrize(
+    "build", [*_SHAPES, pytest.param(lambda: _raw(["search_docs"]), id="raw-low-level")]
+)
+async def test_a_call_naming_no_tool_emits_nothing(build):
+    expected = await _response(build(), "", {})
+    client = FakeClient()
+    server = build()
+    instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
+
+    assert await _response(server, "", {}) == expected
+    await flush_background()
+
+    assert [e["event"] for e in client.events if e["event"] != "$mcp_initialize"] == []
+
+
+@pytest.mark.parametrize("build", _SHAPES)
+async def test_an_unknown_tool_name_is_cut_to_256_characters(build):
+    client = FakeClient()
+    server = build()
+    instrument(server, client, MCPAnalyticsOptions(enable_conversation_id=False))
+
+    await _response(server, "x" * 5000, {})
+    await flush_background()
+
+    [unknown] = events_named(client, "$mcp_unknown_tool")
+    name = unknown["properties"]["$mcp_tool_name"]
+    assert len(name) == 256
+    assert name.startswith("x" * 200)
+
+
+@pytest.mark.parametrize(
+    "build, delivers_handle",
+    [
+        pytest.param(
+            _standalone, True, id="standalone-error-result", marks=_needs_standalone
+        ),
+        pytest.param(_high_level, False, id="high-level-raise"),
+    ],
+)
+async def test_an_unknown_tool_result_carries_the_conversation_handle_it_delivers(
+    build, delivers_handle
+):
+    client = FakeClient()
+    server = build()
+    instrument(server, client)
+
+    _, texts = await _response(server, "no_such_tool", {})
+    await flush_background()
+
+    handles = [
+        json.loads(text)["conversation_id"]
+        for text in texts
+        if text and text.startswith('{"conversation_id"')
+    ]
+    [unknown] = events_named(client, "$mcp_unknown_tool")
+    assert len(handles) == int(delivers_handle)
+    assert unknown["properties"].get("$mcp_conversation_id") == next(
+        iter(handles), None
+    )

From 5f2ee56bb0f2b3815e863045c6506a35ae4053b8 Mon Sep 17 00:00:00 2001
From: Lucas Faria <12522524+lucasheriques@users.noreply.github.com>
Date: Fri, 6 Nov 2026 18:54:35 -0300
Subject: [PATCH 200/245] feat(mcp): declare posthog.mcp stable (#1200)

What: a Versioning section in the posthog.mcp README and a release note saying
the API and the $mcp_* event schema are stable from this release.

Why: posthog.mcp now counts calls the same way as the spec and the other SDKs
(posthog-python#1199), so it can make the stability promise sdk-specs#189
defines. It ships inside posthog 7.x, so there's no separate version bump.

Tested: docs and release note only; no code change.
---
 .sampo/changesets/mcp-python-stable.md | 5 +++++
 posthog/mcp/README.md                  | 4 ++++
 2 files changed, 9 insertions(+)
 create mode 100644 .sampo/changesets/mcp-python-stable.md

diff --git a/.sampo/changesets/mcp-python-stable.md b/.sampo/changesets/mcp-python-stable.md
new file mode 100644
index 000000000..8283c3305
--- /dev/null
+++ b/.sampo/changesets/mcp-python-stable.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+`posthog.mcp` is now stable. From this release, a minor or patch release of `posthog` no longer makes breaking changes to the `posthog.mcp` API, renames or removes a `$mcp_*` event or property, changes its type, or changes which requests send an event, so your saved insights keep working across upgrades. New events and properties can still arrive in minor releases. Upgrading needs no code change.
diff --git a/posthog/mcp/README.md b/posthog/mcp/README.md
index 464036161..d2a0f57fc 100644
--- a/posthog/mcp/README.md
+++ b/posthog/mcp/README.md
@@ -36,6 +36,10 @@ Request headers use the same identity and package version, so SDK Health can com
 Because `$lib` is a client-level identity, `instrument()` relabels every event sent by the client passed to it.
 Use a client dedicated to MCP analytics if the application also captures unrelated events.
 
+## Versioning
+
+`posthog.mcp` is stable. It ships inside the `posthog` package, so it follows that package's version rather than its own. A minor or patch release of `posthog` doesn't change the `posthog.mcp` API in a breaking way, and doesn't rename or remove a `$mcp_*` event or property, change its type, or change which requests send an event, so saved insights keep working across upgrades. It may add events and properties, and redact more of a captured value. The rules come from the [MCP analytics spec](https://github.com/PostHog/sdk-specs/blob/main/openspec/specs/mcp-analytics/spec.md), section "Event schema stability".
+
 ## Defaults and opt-outs
 
 A valid echoed conversation handle takes precedence over transport sessions. A request that already carries a transport session or a PostHog session token does not mint a new handle or append a prompt-back block. Requests carrying neither use the conversation fallback.

From d8a7ff0efa49eb4cf0be8a1b30c1370d6e322553 Mon Sep 17 00:00:00 2001
From: Lucas Faria <12522524+lucasheriques@users.noreply.github.com>
Date: Fri, 6 Nov 2026 19:37:58 -0300
Subject: [PATCH 201/245] fix(mcp): don't read the advertised schema on FastMCP
 2.x (#1203)

* fix(mcp): read the middleware-applied tool listing on FastMCP 2.x

What: _listed_input_schema now falls back to FastMCP 2.x's _list_tools_middleware when the server has no list_tools.
Why: 2.x has no list_tools, so the schema lookup raised, was logged and dropped, and every argument looked undeclared. $mcp_input_keys came back as ['[redacted]'] on 2.x servers with middleware.
Tested: pytest posthog/test/mcp on fastmcp 2.14.7 (661 passed, 14 skipped) and 3.2.0 (665 passed, 10 skipped); ruff format/check and mypy-baseline clean.

* fix(mcp): read the FastMCP 2.x tool registry, not its middleware listing

Review: the 2.x fallback ran _list_tools_middleware, so a request middleware
such as SlidingWindowRateLimitingMiddleware spent a quota slot on the schema
lookup and could fail a call that succeeded before. 2.x now reads get_tools(),
which runs no middleware; 3.x keeps list_tools().

Tested: new test_schema_lookup_on_fastmcp_2_runs_no_request_middleware fails
without the fix and passes with it; pytest posthog/test/mcp on fastmcp 2.14.7
(661 passed; the 1 failure is test_stdio_handshake_then_calls, which fails the
same way locally without this change) and fastmcp 3.2.0 (665 passed); ruff
clean.

* fix(mcp): don't read the advertised schema on FastMCP 2.x

Review on the previous commit: reading the registry with get_tools() can
disagree with what middleware advertises (a replaced tool, a prefixed mount
sharing a root name), so trusting it records undeclared argument names.
Running the middleware listing instead spends rate limits. FastMCP 2.x has no
safe source for the advertised schema, so the lookup now returns None there,
which keeps argument names redacted, runs no middleware, and stops the error
logged on every call. The 2.x middleware test now expects the redaction.

Tested: pytest posthog/test/mcp on fastmcp 2.14.7 (661 passed; the only failure
is test_stdio_handshake_then_calls, which fails locally without this change)
and fastmcp 3.2.0 (665 passed); ruff clean.
---
 .sampo/changesets/mcp-fastmcp2-input-keys.md |  5 ++++
 posthog/mcp/_instrument_lowlevel.py          | 10 +++++--
 posthog/test/mcp/test_fastmcp_v2.py          | 29 +++++++++++++++++++-
 3 files changed, 40 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/mcp-fastmcp2-input-keys.md

diff --git a/.sampo/changesets/mcp-fastmcp2-input-keys.md b/.sampo/changesets/mcp-fastmcp2-input-keys.md
new file mode 100644
index 000000000..9d47767f1
--- /dev/null
+++ b/.sampo/changesets/mcp-fastmcp2-input-keys.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+On FastMCP 2.x servers with middleware, `posthog.mcp` no longer tries to read the advertised tool schema on each call. FastMCP 2.x can only list tools through request middleware, which can spend rate limits, so the lookup failed and logged an error on every call. Argument names there stay redacted in `$mcp_input_keys`, as before.
diff --git a/posthog/mcp/_instrument_lowlevel.py b/posthog/mcp/_instrument_lowlevel.py
index 3d84988a4..a8ab58671 100644
--- a/posthog/mcp/_instrument_lowlevel.py
+++ b/posthog/mcp/_instrument_lowlevel.py
@@ -718,9 +718,13 @@ async def _listed_input_schema(
     """Return the schema that middleware advertises for the current request."""
     try:
         version = _requested_tool_version(meta)
-        candidates = [
-            tool for tool in await high_level.list_tools() if tool.name == name
-        ]
+        list_tools = getattr(high_level, "list_tools", None)
+        if list_tools is None:
+            # FastMCP 2.x only lists through request middleware, which can
+            # spend rate limits, and its registry can disagree with what that
+            # middleware advertises, so the advertised schema is unknown.
+            return None
+        candidates = [tool for tool in await list_tools() if tool.name == name]
         if version is not None:
             candidates = [
                 tool
diff --git a/posthog/test/mcp/test_fastmcp_v2.py b/posthog/test/mcp/test_fastmcp_v2.py
index d8f18b86b..cb1a44817 100644
--- a/posthog/test/mcp/test_fastmcp_v2.py
+++ b/posthog/test/mcp/test_fastmcp_v2.py
@@ -220,7 +220,10 @@ def fresh():
     event = _events(client, "$mcp_tool_call")[0]["properties"]
     assert event["$mcp_llm_model"] == "gpt-5"
     assert event["$mcp_llm_model_source"] == "client_metadata"
-    assert event["$mcp_input_keys"] == ["a", "b"]
+    # FastMCP 2.x can only list through request middleware, so the advertised
+    # schema is unknown there and the undeclared names stay redacted.
+    expected_keys = ["a", "b"] if hasattr(FastMCP, "list_tools") else ["[redacted]"]
+    assert event["$mcp_input_keys"] == expected_keys
 
 
 _OWN_MODEL = {"llm_model": {"type": "string"}}
@@ -699,3 +702,27 @@ async def flaky_get_tool(name, *args, **kwargs):
     assert "real tool ran" in str(out.root.content[0].text)
     assert _events(client, "$mcp_missing_capability") == []
     assert any("delegating the call to your server" in m for m in messages)
+
+
+@pytest.mark.skipif(
+    hasattr(FastMCP, "list_tools"), reason="FastMCP 2.x has no public list_tools"
+)
+async def test_schema_lookup_on_fastmcp_2_runs_no_request_middleware_and_trusts_no_schema():
+    from fastmcp.server.middleware import Middleware
+
+    from posthog.mcp._instrument_lowlevel import _listed_input_schema
+
+    listings = []
+
+    class CountListings(Middleware):
+        async def on_list_tools(self, context, call_next):
+            listings.append(context)
+            return await call_next(context)
+
+    server = make_server()
+    server.add_middleware(CountListings())
+
+    schema = await _listed_input_schema(server, "add", None)
+
+    assert schema is None
+    assert listings == []

From 585a8f6ed4a7fa5af0e099a6d4cace14c352f286 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 23:36:55 +0000
Subject: [PATCH 202/245] chore: Release v7.86.0 [skip ci]

---
 .sampo/changesets/mcp-fastmcp2-input-keys.md |  5 -----
 .sampo/changesets/mcp-python-stable.md       |  5 -----
 .sampo/changesets/mcp-v1-spec-align.md       | 10 ----------
 openfeature-provider/CHANGELOG.md            |  6 ++++++
 openfeature-provider/pyproject.toml          |  2 +-
 posthog/CHANGELOG.md                         | 16 ++++++++++++++++
 posthog/version.py                           |  2 +-
 pyproject.toml                               |  2 +-
 uv.lock                                      |  4 ++--
 9 files changed, 27 insertions(+), 25 deletions(-)
 delete mode 100644 .sampo/changesets/mcp-fastmcp2-input-keys.md
 delete mode 100644 .sampo/changesets/mcp-python-stable.md
 delete mode 100644 .sampo/changesets/mcp-v1-spec-align.md

diff --git a/.sampo/changesets/mcp-fastmcp2-input-keys.md b/.sampo/changesets/mcp-fastmcp2-input-keys.md
deleted file mode 100644
index 9d47767f1..000000000
--- a/.sampo/changesets/mcp-fastmcp2-input-keys.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-On FastMCP 2.x servers with middleware, `posthog.mcp` no longer tries to read the advertised tool schema on each call. FastMCP 2.x can only list tools through request middleware, which can spend rate limits, so the lookup failed and logged an error on every call. Argument names there stay redacted in `$mcp_input_keys`, as before.
diff --git a/.sampo/changesets/mcp-python-stable.md b/.sampo/changesets/mcp-python-stable.md
deleted file mode 100644
index 8283c3305..000000000
--- a/.sampo/changesets/mcp-python-stable.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-`posthog.mcp` is now stable. From this release, a minor or patch release of `posthog` no longer makes breaking changes to the `posthog.mcp` API, renames or removes a `$mcp_*` event or property, changes its type, or changes which requests send an event, so your saved insights keep working across upgrades. New events and properties can still arrive in minor releases. Upgrading needs no code change.
diff --git a/.sampo/changesets/mcp-v1-spec-align.md b/.sampo/changesets/mcp-v1-spec-align.md
deleted file mode 100644
index 718b5a7a0..000000000
--- a/.sampo/changesets/mcp-v1-spec-align.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-pypi/posthog: minor
----
-
-MCP analytics now matches the cross-SDK MCP spec ahead of 1.0:
-
-- `instrument()` sends `$mcp_unknown_tool` instead of a failed `$mcp_tool_call` and `$exception` when a `tools/call` names a tool your server never registered. Insights that count failed tool calls stop counting these. A call naming no tool sends nothing. A raw low-level server has no registry the SDK can read, so a failed call there stays a failed tool call.
-- FastMCP's stock logging, timing, error-handling, and similar middleware no longer turns off `llm_model` injection on standalone `fastmcp.FastMCP`.
-- Manual capture without a `session_id` now sends a fresh `ses_` session id and uses it as the `distinct_id`, instead of no `$session_id` and an `anonymous` person.
-- Truncated string properties now fit their limit with the `...` marker included, so `$mcp_tool_name` and other names stop at 256 characters instead of 259.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index b1b4af81d..6f8e6b5fe 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.150 — 2026-11-06
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.0
+
 ## 0.1.149 — 2026-11-06
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 63ca07ae1..36bde2672 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.149"
+version = "0.1.150"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index ac145095c..5ed7619d2 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,21 @@
 # posthog
 
+## 7.86.0 — 2026-11-06
+
+### Minor changes
+
+- [0aa5df1](https://github.com/posthog/posthog-python/commit/0aa5df18d1c60769de1307677b1e0e649eb023e8) MCP analytics now matches the cross-SDK MCP spec ahead of 1.0:
+  
+  - `instrument()` sends `$mcp_unknown_tool` instead of a failed `$mcp_tool_call` and `$exception` when a `tools/call` names a tool your server never registered. Insights that count failed tool calls stop counting these. A call naming no tool sends nothing. A raw low-level server has no registry the SDK can read, so a failed call there stays a failed tool call.
+  - FastMCP's stock logging, timing, error-handling, and similar middleware no longer turns off `llm_model` injection on standalone `fastmcp.FastMCP`.
+  - Manual capture without a `session_id` now sends a fresh `ses_` session id and uses it as the `distinct_id`, instead of no `$session_id` and an `anonymous` person.
+  - Truncated string properties now fit their limit with the `...` marker included, so `$mcp_tool_name` and other names stop at 256 characters instead of 259. — Thanks @lucasheriques!
+- [5f2ee56](https://github.com/posthog/posthog-python/commit/5f2ee56bb0f2b3815e863045c6506a35ae4053b8) `posthog.mcp` is now stable. From this release, a minor or patch release of `posthog` no longer makes breaking changes to the `posthog.mcp` API, renames or removes a `$mcp_*` event or property, changes its type, or changes which requests send an event, so your saved insights keep working across upgrades. New events and properties can still arrive in minor releases. Upgrading needs no code change. — Thanks @lucasheriques!
+
+### Patch changes
+
+- [d8a7ff0](https://github.com/posthog/posthog-python/commit/d8a7ff0efa49eb4cf0be8a1b30c1370d6e322553) On FastMCP 2.x servers with middleware, `posthog.mcp` no longer tries to read the advertised tool schema on each call. FastMCP 2.x can only list tools through request middleware, which can spend rate limits, so the lookup failed and logged an error on every call. Argument names there stay redacted in `$mcp_input_keys`, as before. — Thanks @lucasheriques!
+
 ## 7.85.0 — 2026-11-06
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 070428720..75ca6facd 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.85.0"
+VERSION = "7.86.0"
diff --git a/pyproject.toml b/pyproject.toml
index 01a40cf23..2cdea6b95 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.85.0"
+version = "7.86.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 2f9644122..fa6a6ffe3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.149"
+version = "0.1.150"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.85.0"
+version = "7.86.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From ac55b350a0f8391593de5f2e2b2fa0d6eebc80dc Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Fri, 6 Nov 2026 23:36:59 +0000
Subject: [PATCH 203/245] Update generated references

---
 .../posthog-python-references-7.86.0.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.0.json

diff --git a/references/posthog-python-references-7.86.0.json b/references/posthog-python-references-7.86.0.json
new file mode 100644
index 000000000..7b9ca3f88
--- /dev/null
+++ b/references/posthog-python-references-7.86.0.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.0",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 8d26a3229..7b9ca3f88 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.85.0",
+    "version": "7.86.0",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From bf3adb3ff90feb11bd7cc06e655451ef6a526edd Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:05:18 +0100
Subject: [PATCH 204/245] fix(flags): return no payload for a failed flag
 record (#1177)

---
 .../changesets/no-payload-for-failed-flag.md  |   5 +
 .../test/fixtures/released_flags_7_82_1.json  |  26 ++++-
 posthog/test/released_flags_scenarios.py      |   3 +-
 posthog/test/test_flags_released_behaviour.py |  31 +++++-
 posthog/test/test_flags_v4_response.py        | 103 ++++++++++++++++++
 posthog/types.py                              |  18 ++-
 6 files changed, 174 insertions(+), 12 deletions(-)
 create mode 100644 .sampo/changesets/no-payload-for-failed-flag.md

diff --git a/.sampo/changesets/no-payload-for-failed-flag.md b/.sampo/changesets/no-payload-for-failed-flag.md
new file mode 100644
index 000000000..69ef828f7
--- /dev/null
+++ b/.sampo/changesets/no-payload-for-failed-flag.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+A flag record that the server marks `failed` no longer returns a payload, even when the record still carries `metadata.payload`. A failed flag reads as disabled, so `get_feature_flag_payload()`, `get_feature_flag_result().payload` and a snapshot's `get_flag_payload()` now return `None` for it, and its `$feature_flag_called` events leave out `$feature_flag_payload`. `get_all_flags_and_payloads()` and `get_feature_payloads()` already left it out. This applies to responses from both `/flags?v=4` and older servers.
diff --git a/posthog/test/fixtures/released_flags_7_82_1.json b/posthog/test/fixtures/released_flags_7_82_1.json
index 627f5336e..2856b2f18 100644
--- a/posthog/test/fixtures/released_flags_7_82_1.json
+++ b/posthog/test/fixtures/released_flags_7_82_1.json
@@ -990,6 +990,9 @@
             "$feature_flag_evaluated_at": 1800000000000,
             "$feature_flag_has_experiment": false,
             "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
             "$feature_flag_reason": "Matched condition set 1",
             "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
             "$feature_flag_response": false,
@@ -1005,6 +1008,9 @@
             "$feature_flag_evaluated_at": 1800000000000,
             "$feature_flag_has_experiment": false,
             "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
             "$feature_flag_reason": "Matched condition set 1",
             "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
             "$feature_flag_response": false,
@@ -1020,6 +1026,9 @@
             "$feature_flag_evaluated_at": 1800000000000,
             "$feature_flag_has_experiment": false,
             "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
             "$feature_flag_reason": "Matched condition set 1",
             "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
             "$feature_flag_response": false,
@@ -1232,6 +1241,9 @@
             "$feature_flag_evaluated_at": 1800000000000,
             "$feature_flag_has_experiment": false,
             "$feature_flag_id": 700,
+            "$feature_flag_payload": {
+              "columns": 2
+            },
             "$feature_flag_reason": "Matched condition set 1",
             "$feature_flag_request_id": "60000000-0000-4000-8000-000000000000",
             "$feature_flag_response": false,
@@ -1366,7 +1378,9 @@
       "get_feature_flag_payload:bool-off": null,
       "get_feature_flag_payload:bool-on": null,
       "get_feature_flag_payload:missing": null,
-      "get_feature_flag_payload:server-failed": null,
+      "get_feature_flag_payload:server-failed": {
+        "columns": 2
+      },
       "get_feature_flag_payload:sparse": null,
       "get_feature_flag_payload:v1-bool-payload": {
         "cta": "Try it",
@@ -1402,7 +1416,9 @@
       "get_feature_flag_result:server-failed": [
         false,
         null,
-        null,
+        {
+          "columns": 2
+        },
         "Matched condition set 1"
       ],
       "get_feature_flag_result:sparse": [
@@ -1559,7 +1575,7 @@
               "description": null,
               "has_experiment": false,
               "id": 700,
-              "payload": null,
+              "payload": "{\"columns\": 2}",
               "version": 3
             },
             "reason": {
@@ -1743,7 +1759,9 @@
       "snapshot.get_flag_payload:bool-off": null,
       "snapshot.get_flag_payload:bool-on": null,
       "snapshot.get_flag_payload:missing": null,
-      "snapshot.get_flag_payload:server-failed": null,
+      "snapshot.get_flag_payload:server-failed": {
+        "columns": 2
+      },
       "snapshot.get_flag_payload:sparse": null,
       "snapshot.get_flag_payload:v1-bool-payload": {
         "cta": "Try it",
diff --git a/posthog/test/released_flags_scenarios.py b/posthog/test/released_flags_scenarios.py
index b3cacdac1..a1fccb10c 100644
--- a/posthog/test/released_flags_scenarios.py
+++ b/posthog/test/released_flags_scenarios.py
@@ -76,7 +76,8 @@ def _flag(key: str, value: Any, **fields: Any) -> Dict[str, Any]:
     _flag("v2-number", 12.5, config_version=2),
     _flag("v2-object", {"layout": "compact", "n": [1, True]}, config_version=2),
     _flag("sparse", "compact", metadata={}, has_experiment=None, reason=None),
-    _flag("server-failed", "compact", failed=True),
+    # A failed record that still carries a payload.
+    _flag("server-failed", "compact", failed=True, payload='{"columns": 2}'),
 ]
 
 
diff --git a/posthog/test/test_flags_released_behaviour.py b/posthog/test/test_flags_released_behaviour.py
index 7ad8022f8..3141dd891 100644
--- a/posthog/test/test_flags_released_behaviour.py
+++ b/posthog/test/test_flags_released_behaviour.py
@@ -38,6 +38,26 @@ def test_every_legacy_getter_and_event_matches_7_82_1(results):
     assert (sparse["id"], sparse["version"]) == (0, 0)
     sparse["id"] = sparse["version"] = None
 
+    # A failed record reads as disabled, so it has no payload, even when the record
+    # carries one. 7.82.1 returned that payload from the payload reads and sent it on
+    # the flag's $feature_flag_called events.
+    failed = expected["get_flags_decision"]["flags"]["server-failed"]["metadata"]
+    assert failed["payload"] == '{"columns": 2}'
+    failed["payload"] = None
+    for read in ["get_feature_flag_payload", "snapshot.get_flag_payload"]:
+        assert expected[f"{read}:server-failed"] == {"columns": 2}
+        expected[f"{read}:server-failed"] = None
+    assert expected["get_feature_flag_result:server-failed"][2] == {"columns": 2}
+    expected["get_feature_flag_result:server-failed"][2] = None
+    failed_events = [
+        properties
+        for _, properties in expected["events"]
+        if properties.get("$feature_flag") == "server-failed"
+    ]
+    assert failed_events
+    for properties in failed_events:
+        assert properties.pop("$feature_flag_payload") == {"columns": 2}
+
     assert results["getters"] == expected
 
 
@@ -71,5 +91,14 @@ def test_fallback_cache_histories_match_7_82_1(results, name):
     # An unreadable record now fails only itself, but a single-flag read of it
     # still reports what 7.82.1 reported when the whole response failed: an
     # unknown_error, no request details, and the cached value.
-    expected = RELEASED["cache histories"][name]
+    expected = copy.deepcopy(RELEASED["cache histories"][name])
+    if name == "good, server failed, timeout":
+        # A failed record has no payload, even when the record carries one, so
+        # neither its read nor the cached result read after the timeout returns
+        # one, and their events leave it out. 7.82.1 returned it from both.
+        for result in expected["results"][1:]:
+            assert result[2] == {"theme": "dark"}
+            result[2] = None
+        for _, properties in expected["events"][1:]:
+            assert properties.pop("$feature_flag_payload") == {"theme": "dark"}
     assert results["cache histories"][name] == expected
diff --git a/posthog/test/test_flags_v4_response.py b/posthog/test/test_flags_v4_response.py
index 662011dce..30e22a7fb 100644
--- a/posthog/test/test_flags_v4_response.py
+++ b/posthog/test/test_flags_v4_response.py
@@ -746,6 +746,109 @@ def test_a_config_version_1_payload_is_kept():
     assert flags["string-flag"].metadata.payload == '{"columns": 2}'
 
 
+def _failed_with_payload(shape: str) -> Dict[str, Any]:
+    """A failed record that still carries a payload, in the given response shape."""
+    if shape == "v4":
+        # A producer-valid failed config version 1 record with a payload.
+        [case] = [c for c in READERS["cases"] if c["id"] == "readers.v1_failed"]
+        response = _build(READERS, case)
+        record = response["flags"]["garden-layout"]
+        assert record["failed"] is True
+        assert record["metadata"]["payload"] == '{"columns":2}'
+        return response
+    record = _older_record(enabled=False, variant=None, failed=True)
+    record["metadata"]["payload"] = '{"columns":2}'
+    return {"flags": {"garden-layout": record}, "requestId": "r1"}
+
+
+@pytest.mark.parametrize("shape", ["v4", "older"])
+def test_a_failed_record_has_no_payload_on_any_read(shape, client):
+    # A failed flag reads as disabled, so a payload on it would surprise the caller.
+    response = _failed_with_payload(shape)
+    [flag] = normalize_flags_response(copy.deepcopy(response))["flags"].values()
+    assert flag._failed is True
+    assert flag.metadata.payload is None
+
+    with mock.patch("posthog.client.flags", return_value=copy.deepcopy(response)):
+        result = client.get_feature_flag_result("garden-layout", DISTINCT_ID)
+        assert result is not None and result.payload is None
+        assert client.get_feature_flag_payload("garden-layout", DISTINCT_ID) is None
+        assert (
+            client.get_feature_flag_payload(
+                "garden-layout", "user-2", send_feature_flag_events=True
+            )
+            is None
+        )
+        payloads = client.get_all_flags_and_payloads(DISTINCT_ID)["featureFlagPayloads"]
+        assert "garden-layout" not in (payloads or {})
+        assert "garden-layout" not in (client.get_feature_payloads(DISTINCT_ID) or {})
+        snapshot = client.evaluate_flags(DISTINCT_ID)
+        assert snapshot.get_flag_payload("garden-layout") is None
+
+
+def _disabled_with_payload(shape: str, failed: Any) -> Dict[str, Any]:
+    """A disabled record that is not failed and carries a payload.
+
+    ``failed`` is the value of the record's ``failed`` field, or ``_ABSENT`` to
+    leave the field out.
+    """
+    if shape == "v4":
+        [case] = [c for c in READERS["cases"] if c["id"] == "readers.v1_at_v4"]
+        response = _build(READERS, case)
+        record = response["flags"]["garden-layout"]
+        record["value"] = False
+        record["reason"] = {"code": "no_condition_match", "condition_index": None}
+        del record["metadata"]["variant_key"]
+        assert record["metadata"]["payload"] == '{"columns":2}'
+    else:
+        record = _older_record(enabled=False, variant=None)
+        record["metadata"]["payload"] = '{"columns":2}'
+        response = {"flags": {"garden-layout": record}, "requestId": "r1"}
+    if failed is _ABSENT:
+        record.pop("failed", None)
+    else:
+        record["failed"] = failed
+    return response
+
+
+_ABSENT = object()
+
+
+# A null ``failed`` is a null optional field, which both parsers ignore, so it is a
+# valid control in both shapes.
+@pytest.mark.parametrize(
+    "failed", [False, None, _ABSENT], ids=["false", "null", "absent"]
+)
+@pytest.mark.parametrize("shape", ["v4", "older"])
+def test_a_disabled_record_that_is_not_failed_keeps_its_payload(shape, failed, client):
+    # The control for the test above: only a failed record loses its payload.
+    response = _disabled_with_payload(shape, failed)
+    [flag] = normalize_flags_response(copy.deepcopy(response))["flags"].values()
+    assert flag._failed is False
+    assert flag.metadata.payload == '{"columns":2}'
+
+    with mock.patch("posthog.client.flags", return_value=copy.deepcopy(response)):
+        result = client.get_feature_flag_result("garden-layout", DISTINCT_ID)
+        assert result is not None and result.payload == {"columns": 2}
+        assert client.get_feature_flag_payload("garden-layout", DISTINCT_ID) == {
+            "columns": 2
+        }
+        snapshot = client.evaluate_flags(DISTINCT_ID)
+        assert snapshot.get_flag_payload("garden-layout") == {"columns": 2}
+
+
+async def test_a_failed_record_has_no_payload_on_the_async_client():
+    with mock.patch(
+        "posthog.async_client._async_flags",
+        new=mock.AsyncMock(return_value=_failed_with_payload("v4")),
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        await client.shutdown()
+
+    assert snapshot.get_flag_payload("garden-layout") is None
+
+
 def test_feature_flag_value_defaults_to_the_legacy_value():
     assert FeatureFlag.from_value_and_payload("a", "control", None)._value == "control"
     assert FeatureFlag.from_value_and_payload("a", True, None)._value is True
diff --git a/posthog/types.py b/posthog/types.py
index 85938a939..370044f84 100644
--- a/posthog/types.py
+++ b/posthog/types.py
@@ -389,13 +389,15 @@ def _parse_typed_record(cls: Type[_F], key: str, resp: Any) -> _F:
         if raw_metadata is None:
             metadata = LegacyFlagMetadata(payload=encoded_payload)
         else:
+            # A number or object value is its own payload; a payload the record also
+            # carries is ignored. A failed record reads as disabled, so it has no
+            # payload, even when the record carries one.
+            payload = encoded_payload
+            if payload is None and not failed:
+                payload = raw_metadata.get("payload")
             metadata = FlagMetadata(
                 id=_read_int(raw_metadata.get("id"), "metadata.id"),
-                # A number or object value is its own payload; a payload the record
-                # also carries is ignored.
-                payload=encoded_payload
-                if encoded_payload is not None
-                else raw_metadata.get("payload"),
+                payload=payload,
                 version=_read_int(raw_metadata.get("version"), "metadata.version"),
                 description=_read_typed(
                     raw_metadata.get("description", ""), "metadata.description", str
@@ -469,6 +471,10 @@ def _parse_older_record(cls: Type[_F], key: str, resp: Dict[str, Any]) -> _F:
     except _MalformedRecord as error:
         return _malformed_record(cls, key, str(error))
 
+    failed = resp.get("failed") is True
+    if failed and raw_metadata:
+        # A failed record has no payload, even when the record carries one.
+        raw_metadata = {**raw_metadata, "payload": None}
     flag = cls(
         key=key,
         # An older server always sends ``enabled``; a record without it keeps
@@ -478,7 +484,7 @@ def _parse_older_record(cls: Type[_F], key: str, resp: Dict[str, Any]) -> _F:
         reason=FlagReason.from_json(raw_reason),
         metadata=FlagMetadata.from_json(raw_metadata),
     )
-    return _set_private_fields(flag, _failed=resp.get("failed") is True)
+    return _set_private_fields(flag, _failed=failed)
 
 
 def _read_record_key(resp: Dict[str, Any]) -> None:

From cbab7c0466d856ce09f939c369694b193546d522 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 08:06:41 +0000
Subject: [PATCH 205/245] chore: Release v7.86.1 [skip ci]

---
 .sampo/changesets/no-payload-for-failed-flag.md | 5 -----
 openfeature-provider/CHANGELOG.md               | 6 ++++++
 openfeature-provider/pyproject.toml             | 2 +-
 posthog/CHANGELOG.md                            | 6 ++++++
 posthog/version.py                              | 2 +-
 pyproject.toml                                  | 2 +-
 uv.lock                                         | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/no-payload-for-failed-flag.md

diff --git a/.sampo/changesets/no-payload-for-failed-flag.md b/.sampo/changesets/no-payload-for-failed-flag.md
deleted file mode 100644
index 69ef828f7..000000000
--- a/.sampo/changesets/no-payload-for-failed-flag.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-A flag record that the server marks `failed` no longer returns a payload, even when the record still carries `metadata.payload`. A failed flag reads as disabled, so `get_feature_flag_payload()`, `get_feature_flag_result().payload` and a snapshot's `get_flag_payload()` now return `None` for it, and its `$feature_flag_called` events leave out `$feature_flag_payload`. `get_all_flags_and_payloads()` and `get_feature_payloads()` already left it out. This applies to responses from both `/flags?v=4` and older servers.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 6f8e6b5fe..c6c83b031 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.151 — 2026-11-09
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.1
+
 ## 0.1.150 — 2026-11-06
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 36bde2672..7cb285d9a 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.150"
+version = "0.1.151"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 5ed7619d2..0ec6ea0e6 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.86.1 — 2026-11-09
+
+### Patch changes
+
+- [bf3adb3f](https://github.com/posthog/posthog-python/commit/bf3adb3ff90feb11bd7cc06e655451ef6a526edd) A flag record that the server marks `failed` no longer returns a payload, even when the record still carries `metadata.payload`. A failed flag reads as disabled, so `get_feature_flag_payload()`, `get_feature_flag_result().payload` and a snapshot's `get_flag_payload()` now return `None` for it, and its `$feature_flag_called` events leave out `$feature_flag_payload`. `get_all_flags_and_payloads()` and `get_feature_payloads()` already left it out. This applies to responses from both `/flags?v=4` and older servers. — Thanks @andehen!
+
 ## 7.86.0 — 2026-11-06
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 75ca6facd..242e30b60 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.0"
+VERSION = "7.86.1"
diff --git a/pyproject.toml b/pyproject.toml
index 2cdea6b95..e564c5bf2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.0"
+version = "7.86.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index fa6a6ffe3..166df9c18 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.150"
+version = "0.1.151"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.0"
+version = "7.86.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From de03040c8e6d9dba78c911c3296fa092fcac2751 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 08:06:46 +0000
Subject: [PATCH 206/245] Update generated references

---
 .../posthog-python-references-7.86.1.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.1.json

diff --git a/references/posthog-python-references-7.86.1.json b/references/posthog-python-references-7.86.1.json
new file mode 100644
index 000000000..687877368
--- /dev/null
+++ b/references/posthog-python-references-7.86.1.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.1",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 7b9ca3f88..687877368 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.0",
+    "version": "7.86.1",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 3c398e597284a7624ee56f589ac070df72600ba7 Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:24:31 +0100
Subject: [PATCH 207/245] fix(capture): retry capture v1 requests that get 404
 or 429 (#1178)

With capture_mode="v1", 404 and 429 now retry like 408 and the 5xx
statuses, with the same backoff, Retry-After handling and retry budget.
They raise CaptureV1Error with their status after the last attempt.
This matches the v1 branch (#1132) and the harness capture v1
retry_behavior suite.
---
 .sampo/changesets/capture-v1-retry-404-429.md |  5 +++++
 AGENTS.md                                     |  2 +-
 posthog/capture_v1.py                         |  9 ++++----
 posthog/test/test_capture_v1.py               | 21 +++++++++++++------
 4 files changed, 25 insertions(+), 12 deletions(-)
 create mode 100644 .sampo/changesets/capture-v1-retry-404-429.md

diff --git a/.sampo/changesets/capture-v1-retry-404-429.md b/.sampo/changesets/capture-v1-retry-404-429.md
new file mode 100644
index 000000000..7e1956f17
--- /dev/null
+++ b/.sampo/changesets/capture-v1-retry-404-429.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+With `capture_mode="v1"`, capture now retries `404` and `429` responses like `408` and `500`, `502`, `503`, `504`, with the same backoff and `Retry-After` handling. Before, both failed the batch at once.
diff --git a/AGENTS.md b/AGENTS.md
index 60e388a4b..31dfbfb4b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,7 +24,7 @@ Follow [Public API changes](./CONTRIBUTING.md#public-api-changes). As an agent,
 
 Before changing capture configuration, serialization, routing, or retries, read the relevant implementation and tests.
 
-Preserve v0 defaults/compatibility; strictly typed v1 options and `$set`/`$set_once` relocation; v1-only compression (zlib-wrapped deflate, optional zstd); partial-only per-event retries with stable identity; accumulated drop reporting even on 2xx; terminal v1 `429`; `Retry-After` as a minimum bounded by the shared 30s ceiling; and inline blocking retries with `sync_mode=True`.
+Preserve v0 defaults/compatibility; strictly typed v1 options and `$set`/`$set_once` relocation; v1-only compression (zlib-wrapped deflate, optional zstd); partial-only per-event retries with stable identity; accumulated drop reporting even on 2xx; v1 retries on `404` and `429` like `408` and 5xx; `Retry-After` as a minimum bounded by the shared 30s ceiling; and inline blocking retries with `sync_mode=True`.
 
 ## Mirror and build safety
 
diff --git a/posthog/capture_v1.py b/posthog/capture_v1.py
index 1ae31ce71..8f29cd706 100644
--- a/posthog/capture_v1.py
+++ b/posthog/capture_v1.py
@@ -81,10 +81,9 @@
 _RESULT_DROP = "drop"
 _RESULT_RETRY = "retry"
 
-# HTTP status classification. 429 is terminal in v1 (unlike v0, where it is
-# retried) — the backend signals overload via retryable 5xx + Retry-After.
-_RETRYABLE_STATUSES = frozenset({408, 500, 502, 503, 504})
-_TERMINAL_STATUSES = frozenset({400, 401, 402, 413, 415, 429})
+# HTTP status classification. 404 and 429 can come from a proxy in front of capture.
+_RETRYABLE_STATUSES = frozenset({404, 408, 429, 500, 502, 503, 504})
+_TERMINAL_STATUSES = frozenset({400, 401, 402, 413, 415})
 
 # Single ceiling (seconds) for the retry backoff: caps the exponential schedule
 # and clamps a server ``Retry-After`` to the same value. Keeps the max retry
@@ -591,7 +590,7 @@ def _send_v1_batch(
             continue
 
         # Non-2xx. Retryable transient statuses back off; everything else
-        # (400/401/402/413/415/429/...) is terminal. Any drops collected from a
+        # (400/401/402/413/415/...) is terminal. Any drops collected from a
         # prior 2xx attempt ride along so on_error still sees them.
         v1_error = CaptureV1Error(
             parsed.status_code,
diff --git a/posthog/test/test_capture_v1.py b/posthog/test/test_capture_v1.py
index f4809d501..56c05af36 100644
--- a/posthog/test/test_capture_v1.py
+++ b/posthog/test/test_capture_v1.py
@@ -664,7 +664,7 @@ def test_malformed_2xx_is_terminal(self) -> None:
         self.assertEqual(len(stub.calls), 1)
         self.assertEqual(exc.status, 200)
 
-    @parameterized.expand([("bad_request", 400), ("rate_limited", 429)])
+    @parameterized.expand([("bad_request", 400), ("billing_limit", 402)])
     def test_terminal_status_raises_immediately(self, _name, status) -> None:
         stub, exc = self._run_expecting_error(
             [_msg("u-1")],
@@ -674,23 +674,32 @@ def test_terminal_status_raises_immediately(self, _name, status) -> None:
         self.assertEqual(len(stub.calls), 1)  # not retried
         self.assertEqual(exc.status, status)
 
-    def test_retryable_status_then_success(self) -> None:
+    @parameterized.expand(
+        [("not_found", 404), ("rate_limited", 429), ("unavailable", 503)]
+    )
+    def test_retryable_status_then_success(self, _name, status) -> None:
         stub = self._run(
             [_msg("u-1")],
             [
-                _FakeResponse(503, headers={"Retry-After": "2"}),
+                _FakeResponse(status, headers={"Retry-After": "2"}),
                 _results_response({"u-1": "ok"}),
             ],
         )
         self.assertEqual(len(stub.calls), 2)
         self.sleep.assert_called_once_with(2.0)  # honored Retry-After
 
-    def test_retryable_status_exhausted_raises(self) -> None:
+    @parameterized.expand(
+        [("not_found", 404), ("rate_limited", 429), ("unavailable", 503)]
+    )
+    def test_retryable_status_exhausted_raises(self, _name, status) -> None:
         stub, exc = self._run_expecting_error(
-            [_msg("u-1")], [_FakeResponse(503), _FakeResponse(503)], max_retries=1
+            [_msg("u-1")], [_FakeResponse(status), _FakeResponse(status)], max_retries=1
         )
         self.assertEqual(len(stub.calls), 2)
-        self.assertEqual(exc.status, 503)
+        self.assertEqual(exc.status, status)
+        self.assertEqual(exc.attempts, 2)
+        # One 1s backoff between the two attempts, none after the final one.
+        self.assertEqual([c.args[0] for c in self.sleep.call_args_list], [1])
 
     def test_transport_error_then_success(self) -> None:
         stub = self._run(

From 39be12a9f8fc7da7fa170cbc41dd01a55e8318ad Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 08:29:03 +0000
Subject: [PATCH 208/245] chore: Release v7.86.2 [skip ci]

---
 .sampo/changesets/capture-v1-retry-404-429.md | 5 -----
 openfeature-provider/CHANGELOG.md             | 6 ++++++
 openfeature-provider/pyproject.toml           | 2 +-
 posthog/CHANGELOG.md                          | 6 ++++++
 posthog/version.py                            | 2 +-
 pyproject.toml                                | 2 +-
 uv.lock                                       | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/capture-v1-retry-404-429.md

diff --git a/.sampo/changesets/capture-v1-retry-404-429.md b/.sampo/changesets/capture-v1-retry-404-429.md
deleted file mode 100644
index 7e1956f17..000000000
--- a/.sampo/changesets/capture-v1-retry-404-429.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-With `capture_mode="v1"`, capture now retries `404` and `429` responses like `408` and `500`, `502`, `503`, `504`, with the same backoff and `Retry-After` handling. Before, both failed the batch at once.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index c6c83b031..bb393488c 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.152 — 2026-11-09
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.2
+
 ## 0.1.151 — 2026-11-09
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 7cb285d9a..83e5c4241 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.151"
+version = "0.1.152"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 0ec6ea0e6..c8dacc5aa 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.86.2 — 2026-11-09
+
+### Patch changes
+
+- [3c398e59](https://github.com/posthog/posthog-python/commit/3c398e597284a7624ee56f589ac070df72600ba7) With `capture_mode="v1"`, capture now retries `404` and `429` responses like `408` and `500`, `502`, `503`, `504`, with the same backoff and `Retry-After` handling. Before, both failed the batch at once. — Thanks @andehen!
+
 ## 7.86.1 — 2026-11-09
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 242e30b60..144977651 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.1"
+VERSION = "7.86.2"
diff --git a/pyproject.toml b/pyproject.toml
index e564c5bf2..6eda2dbfa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.1"
+version = "7.86.2"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 166df9c18..5e474916c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.151"
+version = "0.1.152"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.1"
+version = "7.86.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From bf4a0906bfaa5bd02a4f7a548912218e8f0d99b8 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 08:29:09 +0000
Subject: [PATCH 209/245] Update generated references

---
 .../posthog-python-references-7.86.2.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.2.json

diff --git a/references/posthog-python-references-7.86.2.json b/references/posthog-python-references-7.86.2.json
new file mode 100644
index 000000000..3caf38994
--- /dev/null
+++ b/references/posthog-python-references-7.86.2.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.2",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 687877368..3caf38994 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.1",
+    "version": "7.86.2",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 2a2e5788b31170a3971359af10a561b128bfea03 Mon Sep 17 00:00:00 2001
From: Luan Taraschi <130802253+luantaraschi@users.noreply.github.com>
Date: Mon, 9 Nov 2026 06:55:22 -0300
Subject: [PATCH 210/245] fix(errors): order and mark the stack of a
 never-raised exception (#1181)

* fix(errors): order and mark the stack of a never-raised exception

An exception passed to capture_exception without being raised gets a stack built by the SDK. That stack came out innermost first, started with the SDK's own capture frames, and was sent with mechanism.synthetic false. Build it outermost first like a raised traceback, leave out the SDK frames, and mark it synthetic.

* fix(errors): keep captured exceptions pickleable

Store the id of the synthesized traceback instead of the traceback, which cannot be pickled.

* fix(errors): hold the synthesized traceback and follow the mirror's package

An id can be reused once the traceback is freed, so a pickled or copied exception could report a raised stack as synthetic. Keep the traceback in a small holder compared by identity, which reduces to None when the exception is pickled or deep copied.

The SDK frame check only matched the posthog package, so the posthoganalytics mirror kept its capture frames. Take the package name from the module.

---------

Co-authored-by: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com>
---
 .sampo/changesets/quiet-frost-tapio.md |   5 +
 posthog/exception_utils.py             |  59 +++++++-
 posthog/test/test_exception_capture.py | 179 ++++++++++++++++++++++++-
 3 files changed, 235 insertions(+), 8 deletions(-)
 create mode 100644 .sampo/changesets/quiet-frost-tapio.md

diff --git a/.sampo/changesets/quiet-frost-tapio.md b/.sampo/changesets/quiet-frost-tapio.md
new file mode 100644
index 000000000..660fd5ceb
--- /dev/null
+++ b/.sampo/changesets/quiet-frost-tapio.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+An exception passed to `capture_exception` without being raised now gets its synthesized stack in outermost-first order, without the SDK's own capture frames, and with `mechanism.synthetic` set to `true`.
diff --git a/posthog/exception_utils.py b/posthog/exception_utils.py
index 8608b96f0..a6f5883b2 100644
--- a/posthog/exception_utils.py
+++ b/posthog/exception_utils.py
@@ -681,9 +681,12 @@ def single_exception_from_error_tuple(
         exception_value["mechanism"].setdefault("handled", True)
         exception_value["mechanism"].pop("source", None)
 
-    # Python capture inputs are runtime exceptions and this builder never
-    # replaces their stack with an SDK-generated current stack.
-    exception_value["mechanism"].setdefault("synthetic", False)
+    # The stack is synthetic only when the SDK built it, which happens for an
+    # exception that was passed to capture without ever being raised.
+    exception_value["mechanism"].setdefault(
+        "synthetic",
+        tb is not None and _is_synthesized_traceback(exc_value, tb),
+    )
 
     is_exception_group = BaseExceptionGroup is not None and isinstance(
         exc_value, BaseExceptionGroup
@@ -1048,13 +1051,50 @@ def exc_info_from_error(error):
     return exc_info
 
 
+_SYNTHESIZED_TRACEBACK_ATTR = "__posthog_synthesized_traceback"
+
+# Taken from this module's name because the posthoganalytics mirror is the same
+# code under another package name.
+_SDK_PACKAGE = __name__.partition(".")[0]
+
+
+class _SynthesizedTraceback:
+    """Holds the traceback the SDK built for an exception that was never raised."""
+
+    __slots__ = ("traceback",)
+
+    def __init__(self, traceback):
+        # type: (TracebackType) -> None
+        self.traceback = traceback
+
+    def __reduce__(self):
+        # A pickle or deep copy of the exception has no traceback to mark, and a
+        # traceback can't be pickled. Reducing to None also keeps this class out
+        # of the pickle, so it still loads where the SDK isn't installed.
+        return (type(None), ())
+
+
+def _is_synthesized_traceback(exc_value, tb):
+    # type: (Optional[BaseException], TracebackType) -> bool
+    marker = getattr(exc_value, _SYNTHESIZED_TRACEBACK_ATTR, None)
+    return marker is not None and marker.traceback is tb
+
+
+def _is_sdk_frame(frame):
+    # type: (FrameType) -> bool
+    module = frame.f_globals.get("__name__") or ""
+    return module == _SDK_PACKAGE or module.startswith(_SDK_PACKAGE + ".")
+
+
 def construct_artificial_traceback(e):
     # type: (BaseException) -> None
     if getattr(e, "__traceback__", None) is not None:
         return
 
+    # Collect the current stack innermost first, leaving out the SDK's own
+    # capture frames so the stack ends where the application called the SDK.
     depth = 0
-    frames = []
+    frames = []  # type: List[FrameType]
     while True:
         try:
             frame = sys._getframe(depth)
@@ -1062,15 +1102,20 @@ def construct_artificial_traceback(e):
         except ValueError:
             break
 
+        if not frames and _is_sdk_frame(frame):
+            continue
         frames.append(frame)
 
-    frames.reverse()
-
+    # Link the traceback from the innermost frame outwards, so that following
+    # tb_next walks from the outermost frame to the innermost one, the same
+    # order the interpreter uses for a raised exception.
     tb = None
     for frame in frames:
         tb = types.TracebackType(tb, frame, frame.f_lasti, frame.f_lineno)
 
-    setattr(e, "__traceback__", tb)
+    if tb is not None:
+        setattr(e, "__traceback__", tb)
+        setattr(e, _SYNTHESIZED_TRACEBACK_ATTR, _SynthesizedTraceback(tb))
 
 
 def _module_in_list(name, items):
diff --git a/posthog/test/test_exception_capture.py b/posthog/test/test_exception_capture.py
index 011677779..a8ca09ff4 100644
--- a/posthog/test/test_exception_capture.py
+++ b/posthog/test/test_exception_capture.py
@@ -1,9 +1,12 @@
+import copy
+import importlib.util
+import pickle
 import subprocess
 import sys
 import threading
 from textwrap import dedent
 from types import SimpleNamespace
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -526,3 +529,177 @@ def test_last_inspected_group_member_retains_its_cause_chain():
     ]
     assert exceptions[-1]["mechanism"]["source"] == "cause"
     assert exceptions[-1]["mechanism"]["parent_id"] == 2
+
+
+_APP_MODULE_SOURCE = dedent(
+    """
+    def entry_point(capture, error):
+        return handler(capture, error)
+
+    def handler(capture, error):
+        return capture(error)
+    """
+)
+
+
+def _call_from_app_module(capture, error):
+    # Run the capture call from frames that belong to an application module,
+    # not to the posthog package, the way a real caller would.
+    namespace = {"__name__": "app"}
+    exec(compile(_APP_MODULE_SOURCE, "app.py", "exec"), namespace)
+    return namespace["entry_point"](capture, error)
+
+
+def _exceptions_for_never_raised(error):
+    from posthog.exception_utils import exc_info_from_error, exceptions_from_error_tuple
+
+    return exceptions_from_error_tuple(
+        _call_from_app_module(exc_info_from_error, error)
+    )
+
+
+def test_never_raised_exception_stack_is_outermost_first():
+    exception = _exceptions_for_never_raised(ValueError("never raised"))[0]
+
+    functions = [frame["function"] for frame in exception["stacktrace"]["frames"]]
+    assert functions.index("entry_point") < functions.index("handler")
+    assert functions[-1] == "handler"
+
+
+def test_never_raised_exception_stack_omits_sdk_frames():
+    exception = _exceptions_for_never_raised(ValueError("never raised"))[0]
+
+    functions = [frame["function"] for frame in exception["stacktrace"]["frames"]]
+    assert "construct_artificial_traceback" not in functions
+    assert "exc_info_from_error" not in functions
+
+
+def test_never_raised_exception_stack_is_marked_synthetic():
+    exception = _exceptions_for_never_raised(ValueError("never raised"))[0]
+
+    assert exception["mechanism"]["synthetic"] is True
+
+
+def test_raised_exception_passed_by_object_is_not_synthetic():
+    from posthog.exception_utils import exc_info_from_error, exceptions_from_error_tuple
+
+    try:
+        raise ValueError("raised")
+    except ValueError as error:
+        exceptions = exceptions_from_error_tuple(exc_info_from_error(error))
+
+    assert exceptions[0]["mechanism"]["synthetic"] is False
+
+
+def test_client_capture_of_never_raised_exception_sends_synthetic_stack():
+    from posthog.client import Client
+
+    client = Client("phc_test", sync_mode=True)
+    try:
+        with patch.object(client, "capture", return_value="event-id") as capture:
+            _call_from_app_module(
+                lambda error: client.capture_exception(error, distinct_id="user"),
+                ValueError("never raised"),
+            )
+
+        exception = capture.call_args.kwargs["properties"]["$exception_list"][0]
+        functions = [frame["function"] for frame in exception["stacktrace"]["frames"]]
+        assert exception["mechanism"]["synthetic"] is True
+        assert functions.index("entry_point") < functions.index("handler")
+        assert "capture_exception" not in functions
+    finally:
+        client.shutdown()
+
+
+def test_never_raised_exception_stays_pickleable_after_capture():
+    from posthog.exception_utils import exc_info_from_error
+
+    error = ValueError("never raised")
+    _call_from_app_module(exc_info_from_error, error)
+
+    restored = pickle.loads(pickle.dumps(error))
+
+    assert isinstance(restored, ValueError)
+    assert restored.args == ("never raised",)
+
+
+def test_never_raised_exception_is_not_synthetic_once_raised():
+    from posthog.exception_utils import exc_info_from_error, exceptions_from_error_tuple
+
+    error = ValueError("never raised")
+    _call_from_app_module(exc_info_from_error, error)
+
+    try:
+        raise error
+    except ValueError as raised:
+        exceptions = exceptions_from_error_tuple(exc_info_from_error(raised))
+
+    assert exceptions[0]["mechanism"]["synthetic"] is False
+
+
+def _pickle_round_trip(error):
+    return pickle.loads(pickle.dumps(error))
+
+
+@pytest.mark.parametrize("duplicate", [_pickle_round_trip, copy.copy, copy.deepcopy])
+def test_copy_of_captured_exception_is_not_synthetic_once_raised(duplicate):
+    from posthog.exception_utils import exc_info_from_error, exceptions_from_error_tuple
+
+    # Capture inline, so no application frame keeps the exception alive and the
+    # synthesized traceback is freed as soon as the original goes away. Its
+    # address is then free for the traceback of the raise below.
+    for _ in range(50):
+        error = ValueError("never raised")
+        exc_info_from_error(error)
+        duplicated = duplicate(error)
+        del error
+
+        try:
+            raise duplicated
+        except ValueError as raised:
+            exceptions = exceptions_from_error_tuple(exc_info_from_error(raised))
+
+        assert exceptions[0]["mechanism"]["synthetic"] is False
+
+
+def test_captured_exception_can_be_unpickled_without_the_sdk():
+    from posthog.exception_utils import exc_info_from_error
+
+    error = ValueError("never raised")
+    _call_from_app_module(exc_info_from_error, error)
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-I",
+            "-S",
+            "-c",
+            "import pickle, sys; print(pickle.loads(sys.stdin.buffer.read()))",
+        ],
+        input=pickle.dumps(error),
+        capture_output=True,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert result.stdout.strip() == b"never raised"
+
+
+def test_never_raised_exception_stack_omits_sdk_frames_in_renamed_package():
+    import posthog.exception_utils as exception_utils
+
+    # The posthoganalytics mirror ships this module under another package name.
+    spec = importlib.util.spec_from_file_location(
+        "posthoganalytics.exception_utils", exception_utils.__file__
+    )
+    mirror = importlib.util.module_from_spec(spec)
+    with patch.dict(sys.modules, {spec.name: mirror}):
+        spec.loader.exec_module(mirror)
+        exception = mirror.exceptions_from_error_tuple(
+            _call_from_app_module(
+                mirror.exc_info_from_error, ValueError("never raised")
+            )
+        )[0]
+
+    functions = [frame["function"] for frame in exception["stacktrace"]["frames"]]
+    assert functions[-1] == "handler"
+    assert exception["mechanism"]["synthetic"] is True

From 68e28b621560df11c166fd8786296e915af3c6dd Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:57:52 +0000
Subject: [PATCH 211/245] chore: Release v7.86.3 [skip ci]

---
 .sampo/changesets/quiet-frost-tapio.md | 5 -----
 openfeature-provider/CHANGELOG.md      | 6 ++++++
 openfeature-provider/pyproject.toml    | 2 +-
 posthog/CHANGELOG.md                   | 6 ++++++
 posthog/version.py                     | 2 +-
 pyproject.toml                         | 2 +-
 uv.lock                                | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/quiet-frost-tapio.md

diff --git a/.sampo/changesets/quiet-frost-tapio.md b/.sampo/changesets/quiet-frost-tapio.md
deleted file mode 100644
index 660fd5ceb..000000000
--- a/.sampo/changesets/quiet-frost-tapio.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-An exception passed to `capture_exception` without being raised now gets its synthesized stack in outermost-first order, without the SDK's own capture frames, and with `mechanism.synthetic` set to `true`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index bb393488c..7da0053f6 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.153 — 2026-11-09
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.3
+
 ## 0.1.152 — 2026-11-09
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 83e5c4241..3691bd186 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.152"
+version = "0.1.153"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index c8dacc5aa..d60f82cbc 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.86.3 — 2026-11-09
+
+### Patch changes
+
+- [2a2e5788](https://github.com/posthog/posthog-python/commit/2a2e5788b31170a3971359af10a561b128bfea03) An exception passed to `capture_exception` without being raised now gets its synthesized stack in outermost-first order, without the SDK's own capture frames, and with `mechanism.synthetic` set to `true`. — Thanks @luantaraschi!
+
 ## 7.86.2 — 2026-11-09
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 144977651..cd62ba152 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.2"
+VERSION = "7.86.3"
diff --git a/pyproject.toml b/pyproject.toml
index 6eda2dbfa..ccf96813e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.2"
+version = "7.86.3"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 5e474916c..90d5640d8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2669,7 +2669,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.152"
+version = "0.1.153"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3206,7 +3206,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.2"
+version = "7.86.3"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 352925c8b630776107e2dd8770cde82336ff5e98 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:57:57 +0000
Subject: [PATCH 212/245] Update generated references

---
 .../posthog-python-references-7.86.3.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.3.json

diff --git a/references/posthog-python-references-7.86.3.json b/references/posthog-python-references-7.86.3.json
new file mode 100644
index 000000000..2ed52742a
--- /dev/null
+++ b/references/posthog-python-references-7.86.3.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.3",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 3caf38994..2ed52742a 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.2",
+    "version": "7.86.3",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 27c12a37653135df9b94dd089145352b63bce034 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 16:05:45 +0200
Subject: [PATCH 213/245] chore(deps): bump the github-actions group across 1
 directory with 7 updates (#1214)

Bumps the github-actions group with 7 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [actions/setup-python](https://github.com/actions/setup-python) | `7.0.0` | `7.1.0` |
| [astral-sh/setup-uv](https://github.com/astral-sh/setup-uv) | `10.3.0` | `10.3.3` |
| [actions/upload-artifact](https://github.com/actions/upload-artifact) | `7.0.1` | `7.0.2` |
| [github/codeql-action/init](https://github.com/github/codeql-action) | `4.39.0` | `4.39.1` |
| [github/codeql-action/analyze](https://github.com/github/codeql-action) | `4.39.0` | `4.39.1` |
| [pypa/gh-action-pypi-publish](https://github.com/pypa/gh-action-pypi-publish) | `1.14.2` | `1.14.3` |
| [PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml](https://github.com/posthog/posthog-sdk-test-harness) | `1.17.0` | `1.27.0` |



Updates `actions/setup-python` from 7.0.0 to 7.1.0
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/5fda3b95a4ea91299a34e894583c3862153e4b97...6d4fd22b20465ccc0f7354476588e8df7c9ca0e0)

Updates `astral-sh/setup-uv` from 10.3.0 to 10.3.3
- [Release notes](https://github.com/astral-sh/setup-uv/releases)
- [Commits](https://github.com/astral-sh/setup-uv/compare/1c37ad07a6a961277cf70c0d37d6f313000f5884...68559e99cc807c1eb7e9238fd43a15bba460eec2)

Updates `actions/upload-artifact` from 7.0.1 to 7.0.2
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/043fb46d1a93c77aae656e7c1c64a875d1fc6a0a...cf430e030ddbb5b0abf93d22962f4752f3646cd9)

Updates `github/codeql-action/init` from 4.39.0 to 4.39.1
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee...9b3254085494b55a0f7c4c2b3d2d52cc712ce370)

Updates `github/codeql-action/analyze` from 4.39.0 to 4.39.1
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee...9b3254085494b55a0f7c4c2b3d2d52cc712ce370)

Updates `pypa/gh-action-pypi-publish` from 1.14.2 to 1.14.3
- [Release notes](https://github.com/pypa/gh-action-pypi-publish/releases)
- [Commits](https://github.com/pypa/gh-action-pypi-publish/compare/dc37677b2e1c63e2034f94d8a5b11f265b73ba33...7245906fb61fa33a13554f9d5fb856fe61758086)

Updates `PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml` from 1.17.0 to 1.27.0
- [Release notes](https://github.com/posthog/posthog-sdk-test-harness/releases)
- [Changelog](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/CHANGELOG.md)
- [Commits](https://github.com/posthog/posthog-sdk-test-harness/compare/8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3...75fb00092c6045daef60c30acc10ac83afefbfe9)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-version: 7.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: astral-sh/setup-uv
  dependency-version: 10.3.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: actions/upload-artifact
  dependency-version: 7.0.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.39.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.39.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: pypa/gh-action-pypi-publish
  dependency-version: 1.14.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml
  dependency-version: 1.27.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/benchmarks.yml      | 10 +++++-----
 .github/workflows/ci.yml              | 28 +++++++++++++--------------
 .github/workflows/codeql.yml          |  4 ++--
 .github/workflows/posthog-upgrade.yml |  2 +-
 .github/workflows/release.yml         | 16 +++++++--------
 .github/workflows/sdk-compliance.yml  |  6 +++---
 6 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index 97b769661..a41910600 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -25,11 +25,11 @@ jobs:
                   fetch-depth: 0
                   persist-credentials: false
 
-            - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+            - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: '3.12.12'
 
-            - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+            - uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: '0.13.4'
                   enable-cache: true
@@ -69,7 +69,7 @@ jobs:
 
             - name: Upload raw shard results
               if: always()
-              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
               with:
                   name: benchmark-shard-${{ matrix.shard }}
                   path: |
@@ -110,7 +110,7 @@ jobs:
 
             - name: Upload rendered comparison
               if: always()
-              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
               with:
                   name: python-benchmark-report
                   path: |
@@ -122,7 +122,7 @@ jobs:
             - name: Upload raw benchmark results
               if: always()
               id: results
-              uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+              uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
               with:
                   name: python-benchmark-results
                   path: |
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ecbc6914c..ef0ff8a61 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -87,7 +87,7 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python 3.11
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: 3.11
 
@@ -104,12 +104,12 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python 3.11
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: 3.11
 
             - name: Install uv
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
@@ -132,12 +132,12 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python ${{ matrix.python-version }}
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
@@ -179,12 +179,12 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python ${{ matrix.python-version }}
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
@@ -244,13 +244,13 @@ jobs:
 
             - name: Set up Python 3.11
               if: steps.changes.outputs.changed == 'true'
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: 3.11
 
             - name: Install uv
               if: steps.changes.outputs.changed == 'true'
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
@@ -303,7 +303,7 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python ${{ matrix.python-version }}
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: ${{ matrix.python-version }}
 
@@ -326,12 +326,12 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python ${{ matrix.python-version }}
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: ${{ matrix.python-version }}
 
             - name: Install uv
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
@@ -381,12 +381,12 @@ jobs:
                   fetch-depth: 1
 
             - name: Set up Python 3.12
-              uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+              uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
               with:
                   python-version: 3.12
 
             - name: Install uv
-              uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+              uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
               with:
                   version: "0.13.4"
                   enable-cache: true
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index ea90e4ce8..8ad9f734f 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -40,6 +40,6 @@ jobs:
           trap-caching: false
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
         with:
           category: '/language:${{matrix.language}}'
diff --git a/.github/workflows/posthog-upgrade.yml b/.github/workflows/posthog-upgrade.yml
index 0c1f8126f..55fc6718f 100644
--- a/.github/workflows/posthog-upgrade.yml
+++ b/.github/workflows/posthog-upgrade.yml
@@ -42,7 +42,7 @@ jobs:
           token: ${{ steps.upgrader.outputs.token }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
         with:
           version: "0.13.4"
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0dd57cb0a..f644b94f9 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -96,12 +96,12 @@ jobs:
           token: ${{ steps.releaser.outputs.token }}
 
       - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: 3.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
         with:
           version: "0.13.4"
           enable-cache: true
@@ -301,12 +301,12 @@ jobs:
         run: git fetch --tags --force
 
       - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: 3.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
         with:
           version: "0.13.4"
           enable-cache: true
@@ -346,7 +346,7 @@ jobs:
 
       - name: Publish ${{ matrix.package.name }} to PyPI
         if: steps.detect.outputs.has-new-version == 'true'
-        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3
         with:
           packages-dir: ${{ matrix.package.packages_dir }}
 
@@ -468,12 +468,12 @@ jobs:
           fetch-depth: 0
 
       - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: 3.11
 
       - name: Install uv
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3
         with:
           version: "0.13.4"
           enable-cache: true
@@ -505,7 +505,7 @@ jobs:
         run: uv build --package openfeature-provider-posthog --out-dir openfeature-provider/dist
 
       - name: Publish to TestPyPI
-        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3
         with:
           packages-dir: openfeature-provider/dist
           repository-url: https://test.pypi.org/legacy/
diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index 2df4d111c..02d787e64 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -19,7 +19,7 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
         with:
           python-version: "3.12"
       - name: Install adapter and test dependencies
@@ -29,7 +29,7 @@ jobs:
 
   compliance:
     name: PostHog SDK compliance tests (capture v0)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3 # 1.17.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@75fb00092c6045daef60c30acc10ac83afefbfe9 # 1.27.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
@@ -39,7 +39,7 @@ jobs:
 
   compliance-v1:
     name: PostHog SDK compliance tests (capture v1)
-    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@8ca75c478d8a1b7d5be3f9b82b1a744b8ee630c3 # 1.17.0
+    uses: PostHog/posthog-sdk-test-harness/.github/workflows/test-sdk-action.yml@75fb00092c6045daef60c30acc10ac83afefbfe9 # 1.27.0
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."

From b7b962add77c0c36275ef719e8c44c2f45ed7aeb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:17:44 -0500
Subject: [PATCH 214/245] chore(deps): bump joserfc from 1.7.1 to 1.7.6 (#1161)

Bumps [joserfc](https://github.com/authlib/joserfc) from 1.7.1 to 1.7.6.
- [Release notes](https://github.com/authlib/joserfc/releases)
- [Changelog](https://github.com/authlib/joserfc/blob/main/docs/changelog.rst)
- [Commits](https://github.com/authlib/joserfc/compare/1.7.1...1.7.6)

---
updated-dependencies:
- dependency-name: joserfc
  dependency-version: 1.7.6
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index 90d5640d8..1c9e59003 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1690,14 +1690,14 @@ wheels = [
 
 [[package]]
 name = "joserfc"
-version = "1.7.1"
+version = "1.7.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/44/90/25cb27518750218e4f850be63d8bbb2343efaad1c01c3571aaa4b3c33bd7/joserfc-1.7.1.tar.gz", hash = "sha256:77d0b76514879c68c6f433bc5b7357a4ab72008ff1e33d8379fd11d72bd8ca81", size = 233181, upload-time = "2026-06-08T07:21:33.412Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/db/ec5b5fe07a7bda62cd2c2d619daf160eb7442b979c7cd61bbe0262108de9/joserfc-1.7.6.tar.gz", hash = "sha256:fb1cf6d2977318bef976c2ed2ef2167cc5f8ade8fc96f034e38f7abd656907c4", size = 236091, upload-time = "2026-10-18T23:12:18.43Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/00/fa62404c3e347f946faa13aa21085205f9cc06ad17671e37f81a51662ae8/joserfc-1.7.1-py3-none-any.whl", hash = "sha256:b3e3d655612e2e1ef67b2600f2f420e12e537b020208fab1761fad647319c164", size = 70423, upload-time = "2026-06-08T07:21:32.001Z" },
+    { url = "https://files.pythonhosted.org/packages/98/40/63886ba742c6fd9e6dd222e20b8d54012fbc933465350c7747c4ed5b31e4/joserfc-1.7.6-py3-none-any.whl", hash = "sha256:e2d72e3fa937ed8ddd42ad8c1cc337a43e7ffd02efa572a2aa15e2764a05b506", size = 71588, upload-time = "2026-10-18T23:12:17.085Z" },
 ]
 
 [[package]]

From 0ee202e9795ef8ca8e38c9339c9086ac7cb775b4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:17:51 -0500
Subject: [PATCH 215/245] chore(deps): bump virtualenv from 21.7.13 to 21.14.13
 (#1162)

Bumps [virtualenv](https://github.com/pypa/virtualenv) from 21.7.13 to 21.14.13.
- [Release notes](https://github.com/pypa/virtualenv/releases)
- [Changelog](https://github.com/pypa/virtualenv/blob/main/docs/changelog.rst)
- [Commits](https://github.com/pypa/virtualenv/compare/21.7.13...21.14.13)

---
updated-dependencies:
- dependency-name: virtualenv
  dependency-version: 21.14.13
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 51 +++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 37 insertions(+), 14 deletions(-)

diff --git a/uv.lock b/uv.lock
index 1c9e59003..fb87d7e3e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -905,11 +905,11 @@ wheels = [
 
 [[package]]
 name = "distlib"
-version = "0.3.9"
+version = "0.4.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923, upload-time = "2024-10-09T18:35:47.551Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973, upload-time = "2024-10-09T18:35:44.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" },
 ]
 
 [[package]]
@@ -1060,7 +1060,8 @@ dependencies = [
     { name = "openapi-pydantic" },
     { name = "opentelemetry-api" },
     { name = "packaging" },
-    { name = "platformdirs" },
+    { name = "platformdirs", version = "4.12.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "platformdirs", version = "4.13.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] },
     { name = "pydantic", extra = ["email"] },
     { name = "pyperclip" },
@@ -3130,11 +3131,11 @@ wheels = [
 
 [[package]]
 name = "packaging"
-version = "24.2"
+version = "26.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" },
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
 ]
 
 [[package]]
@@ -3188,11 +3189,31 @@ wheels = [
 
 [[package]]
 name = "platformdirs"
-version = "4.3.8"
+version = "4.12.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362, upload-time = "2025-05-07T22:47:42.121Z" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/a1/d5f9002a70298c64a789779077d8dd90c10aa1f47fe40c86802df874f2a6/platformdirs-4.12.4.tar.gz", hash = "sha256:63743c02414e755de4e31b8f68125c1407495b86c5a006e203c01ff8b9924250", size = 60010, upload-time = "2026-10-07T23:30:32.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/ba/223e00b885e960edd5d4b4d178c88acce019bd5b83786093681b8c393492/platformdirs-4.12.4-py3-none-any.whl", hash = "sha256:78bfb9db2a8471ed7eebe3c3c932da413911042994e699b384fbb4493fa872d7", size = 32596, upload-time = "2026-10-07T23:30:30.825Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.13.5"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*'",
+    "python_full_version == '3.11.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/e6/d0abbb256b44e6a05748c6942511ff67db8dbb068de0c35b24bf1b395b09/platformdirs-4.13.5.tar.gz", hash = "sha256:05831adf87d392760f4b5c3a0a95579ab5a10b18b9b9bd43680dcb47544788a0", size = 62362, upload-time = "2026-10-19T01:02:11.778Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/8a/1d8cb3842909dc193a73835adedf412e32e18f8ffd59f43983949622fe6f/platformdirs-4.13.5-py3-none-any.whl", hash = "sha256:53d3ec4280b815c1e0b02edad7f9ee8fda1ba9c0865dd9c2e6e63849ce82fc1e", size = 32779, upload-time = "2026-10-19T01:02:10.17Z" },
 ]
 
 [[package]]
@@ -4698,18 +4719,20 @@ wheels = [
 
 [[package]]
 name = "virtualenv"
-version = "21.7.13"
+version = "21.14.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "distlib" },
     { name = "filelock" },
-    { name = "platformdirs" },
+    { name = "packaging" },
+    { name = "platformdirs", version = "4.12.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "platformdirs", version = "4.13.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "python-discovery" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/13/50/c9b84eb106d0db420b9878dac0a386c5791726f127ce20b06897f6e3a1e9/virtualenv-21.7.13.tar.gz", hash = "sha256:0355558b6f33619aab31347e43643b0ebc97f61ea3acf617b2b69e1f8a843d11", size = 5360306, upload-time = "2026-09-18T04:35:49.354Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/aa/bff50daee0488e16d611258a9b6c5a1d0c9e128f8ca424e9f4e1c0444ef2/virtualenv-21.14.13.tar.gz", hash = "sha256:de5307ba4b9a0001d9c8ea02832d38f63ca432880f416c1bface61c4323fd905", size = 5570301, upload-time = "2026-10-22T20:10:16.952Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/ce/e74453531b0c49a58d0e8a4f9bab4495705859fee4a4f7de27d58f4a791a/virtualenv-21.7.13-py3-none-any.whl", hash = "sha256:1bea5af7463f59c4719db48fe739579a2a4f569c96f26c086edda85c96da9f59", size = 5328680, upload-time = "2026-09-18T04:35:47.194Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/a9/c10d8a44a29fb94a18b43fdf11f38caca53ae7c9406f11a72b1cb8f624f1/virtualenv-21.14.13-py3-none-any.whl", hash = "sha256:5fbb04138a4861580b78ba9110d529a26bc48fcc93c8ec36bc0202eeed96a788", size = 5557094, upload-time = "2026-10-22T20:10:15.096Z" },
 ]
 
 [[package]]

From 9be86e7cdbcfdd24a13f6c5e05ea1f18893e2f9b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:18:03 -0500
Subject: [PATCH 216/245] chore(deps): bump pyasn1 from 0.6.4 to 0.6.5 (#1197)

Bumps [pyasn1](https://github.com/pyasn1/pyasn1) from 0.6.4 to 0.6.5.
- [Release notes](https://github.com/pyasn1/pyasn1/releases)
- [Changelog](https://github.com/pyasn1/pyasn1/blob/main/CHANGES.rst)
- [Commits](https://github.com/pyasn1/pyasn1/compare/v0.6.4...v0.6.5)

---
updated-dependencies:
- dependency-name: pyasn1
  dependency-version: 0.6.5
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uv.lock b/uv.lock
index fb87d7e3e..8cfdfce7f 100644
--- a/uv.lock
+++ b/uv.lock
@@ -3595,11 +3595,11 @@ memory = [
 
 [[package]]
 name = "pyasn1"
-version = "0.6.4"
+version = "0.6.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a4/9a/23310166d960def5897e91fe20e5b724601b02a22e84ba1f94232c0b7f67/pyasn1-0.6.4.tar.gz", hash = "sha256:9c447d8431c947fe4c8febc4ed9e760bc29011a5b01e5c74b67025bd9fb8ce81", size = 151262, upload-time = "2026-07-09T01:12:33.988Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/88/7e/3c0da41061a2021cac7cd524fd57092adbe5b515e8bf9005702e366802e2/pyasn1-0.6.5.tar.gz", hash = "sha256:6b11616a6bcf3a40e635f082bb232fa57b5e0dd7f517bd7ddd69ec3794508a47", size = 155152, upload-time = "2026-10-27T06:32:49.125Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3b/6163796d69c3977d1e4287bea4a6979161cbbdd170ebb430511e8e1999ce/pyasn1-0.6.4-py3-none-any.whl", hash = "sha256:deda9277cfd454080ec40b207fb6df82206a3a2688735233cdcd8d3d565f088b", size = 84410, upload-time = "2026-07-09T01:12:32.92Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1f/3eefd5c84c35cae44549ce1c7f7e58f7945b34f5a6bce07a135438522073/pyasn1-0.6.5-py3-none-any.whl", hash = "sha256:4017b0fce125096b8573b39c989fdb1a4b19cf761e683398184550fea0e66587", size = 84807, upload-time = "2026-10-27T06:32:48.045Z" },
 ]
 
 [[package]]

From 2c35f0472a45b809e7b024a31edf1c85c60a391a Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Mon, 9 Nov 2026 10:32:42 -0400
Subject: [PATCH 217/245] fix(ai): capture an error event when a streaming call
 fails to connect (#1146)

* fix(ai): capture an error event when a streaming call fails to connect

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>

* fix(ai): annotate the Gemini streaming accumulator for mypy

* fix(ai): keep the provider error when capturing a failed streaming connect

If building the telemetry event raises (for example while formatting
input the provider just rejected), the capture error replaced the
original exception. Log it instead and re-raise the provider error.

Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>

* fix(ai): do not let telemetry failures mask a streaming connect error

If capturing the connect-error event itself raised (e.g. unformattable input),
the capture exception replaced the provider error. Wrap the capture in each
OpenAI/Gemini wrapper, log a fixed message, and re-raise the original error.
The Anthropic fallback log no longer includes the exception text or traceback.

Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>

---------

Signed-off-by: Alex Castillo <alex.castillog33@gmail.com>
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 .sampo/changesets/stream-connect-error.md     |   5 +
 posthog/ai/anthropic/anthropic.py             |  26 +-
 posthog/ai/anthropic/anthropic_async.py       |  27 +-
 posthog/ai/gemini/gemini.py                   |  32 ++-
 posthog/ai/gemini/gemini_async.py             |  34 ++-
 posthog/ai/openai/openai.py                   |  45 +++-
 posthog/ai/openai/openai_async.py             |  45 +++-
 .../test/ai/test_stream_midstream_error.py    | 247 ++++++++++++++++++
 8 files changed, 449 insertions(+), 12 deletions(-)
 create mode 100644 .sampo/changesets/stream-connect-error.md

diff --git a/.sampo/changesets/stream-connect-error.md b/.sampo/changesets/stream-connect-error.md
new file mode 100644
index 000000000..9f684067b
--- /dev/null
+++ b/.sampo/changesets/stream-connect-error.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Capture an `$ai_generation` error event when `create(stream=True)` fails before the stream starts (bad key, rate limit, invalid model) in the OpenAI chat, OpenAI Responses, Anthropic and Gemini wrappers, sync and async. Previously only errors raised mid-stream were captured.
diff --git a/posthog/ai/anthropic/anthropic.py b/posthog/ai/anthropic/anthropic.py
index 704cacb20..ef4c4dacb 100644
--- a/posthog/ai/anthropic/anthropic.py
+++ b/posthog/ai/anthropic/anthropic.py
@@ -6,6 +6,7 @@
         "Please install the Anthropic SDK to use this feature: 'pip install anthropic'"
     )
 
+import logging
 import time
 import uuid
 from typing import Any, Dict, List, Optional
@@ -31,6 +32,8 @@
 from posthog.client import Client as PostHogClient
 from posthog import setup
 
+_log = logging.getLogger("posthog")
+
 
 class Anthropic(anthropic.Anthropic):
     """
@@ -162,7 +165,28 @@ def _create_streaming(
         **kwargs: Any,
     ):
         start_time = time.time()
-        response = super().create(**kwargs)
+        try:
+            response = super().create(**kwargs)
+        except Exception as exc:
+            accumulator = _AnthropicStreamAccumulator()
+            try:
+                self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    accumulator.usage_stats,
+                    time.time() - start_time,
+                    accumulator.content_blocks,
+                    accumulator.accumulated_content,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
         return self._track_streaming_response(
             response,
             posthog_distinct_id,
diff --git a/posthog/ai/anthropic/anthropic_async.py b/posthog/ai/anthropic/anthropic_async.py
index 5207fa6b4..80014ce91 100644
--- a/posthog/ai/anthropic/anthropic_async.py
+++ b/posthog/ai/anthropic/anthropic_async.py
@@ -6,11 +6,13 @@
         "Please install the Anthropic SDK to use this feature: 'pip install anthropic'"
     )
 
+import logging
 import time
 import uuid
 from typing import Any, Dict, List, Optional
 
 from posthog import setup
+
 from ..stream import AsyncStreamWrapper as AsyncStreamWrapper
 from ..types import (
     StreamingContentBlock as StreamingContentBlock,
@@ -31,6 +33,8 @@
 )
 from posthog.client import Client as PostHogClient
 
+_log = logging.getLogger("posthog")
+
 
 class AsyncAnthropic(anthropic.AsyncAnthropic):
     """
@@ -162,7 +166,28 @@ async def _create_streaming(
         **kwargs: Any,
     ):
         start_time = time.time()
-        response = await super().create(**kwargs)
+        try:
+            response = await super().create(**kwargs)
+        except Exception as exc:
+            accumulator = _AnthropicStreamAccumulator()
+            try:
+                await self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    accumulator.usage_stats,
+                    time.time() - start_time,
+                    accumulator.content_blocks,
+                    accumulator.accumulated_content,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
         return self._track_streaming_response(
             response,
             posthog_distinct_id,
diff --git a/posthog/ai/gemini/gemini.py b/posthog/ai/gemini/gemini.py
index 485e2adee..42d5cb688 100644
--- a/posthog/ai/gemini/gemini.py
+++ b/posthog/ai/gemini/gemini.py
@@ -1,3 +1,4 @@
+import logging
 import time
 from typing import Any, Dict, Optional
 
@@ -29,6 +30,8 @@
     format_gemini_streaming_output as format_gemini_streaming_output,
 )
 
+_log = logging.getLogger("posthog")
+
 
 class Client:
     """
@@ -257,11 +260,36 @@ def _generate_content_streaming(
     ):
         start_time = time.time()
         usage_stats: TokenUsage = TokenUsage()
-        accumulated_content = []
+        accumulated_content: list[Any] = []
         stop_reason: Optional[str] = None
 
         kwargs_without_stream = {"model": model, "contents": contents, **kwargs}
-        response = self._client.models.generate_content_stream(**kwargs_without_stream)
+        try:
+            response = self._client.models.generate_content_stream(
+                **kwargs_without_stream
+            )
+        except Exception as exc:
+            try:
+                self._capture_streaming_event(
+                    model,
+                    contents,
+                    distinct_id,
+                    trace_id,
+                    properties,
+                    privacy_mode,
+                    groups,
+                    kwargs,
+                    usage_stats,
+                    time.time() - start_time,
+                    accumulated_content,
+                    stop_reason=stop_reason,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         def generator():
             nonlocal usage_stats
diff --git a/posthog/ai/gemini/gemini_async.py b/posthog/ai/gemini/gemini_async.py
index 6823743ed..3b0d45c69 100644
--- a/posthog/ai/gemini/gemini_async.py
+++ b/posthog/ai/gemini/gemini_async.py
@@ -1,3 +1,4 @@
+import logging
 import time
 from typing import Any, Dict, Optional
 
@@ -29,6 +30,8 @@
     format_gemini_streaming_output as format_gemini_streaming_output,
 )
 
+_log = logging.getLogger("posthog")
+
 
 class AsyncClient:
     """
@@ -241,13 +244,36 @@ async def _generate_content_streaming(
     ):
         start_time = time.time()
         usage_stats: TokenUsage = TokenUsage()
-        accumulated_content = []
+        accumulated_content: list[Any] = []
         stop_reason: Optional[str] = None
 
         kwargs_without_stream = {"model": model, "contents": contents, **kwargs}
-        response = await self._client.aio.models.generate_content_stream(
-            **kwargs_without_stream
-        )
+        try:
+            response = await self._client.aio.models.generate_content_stream(
+                **kwargs_without_stream
+            )
+        except Exception as exc:
+            try:
+                self._capture_streaming_event(
+                    model,
+                    contents,
+                    distinct_id,
+                    trace_id,
+                    properties,
+                    privacy_mode,
+                    groups,
+                    kwargs,
+                    usage_stats,
+                    time.time() - start_time,
+                    accumulated_content,
+                    stop_reason=stop_reason,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         async def async_generator():
             nonlocal usage_stats
diff --git a/posthog/ai/openai/openai.py b/posthog/ai/openai/openai.py
index 998e3fd15..e00a2d3c0 100644
--- a/posthog/ai/openai/openai.py
+++ b/posthog/ai/openai/openai.py
@@ -1,3 +1,4 @@
+import logging
 import time
 import uuid
 from typing import TYPE_CHECKING as _TYPE_CHECKING, Any, Dict, Optional
@@ -41,6 +42,8 @@
     merge_provider_override,
 )
 
+_log = logging.getLogger("posthog")
+
 
 class OpenAI(openai.OpenAI):
     """
@@ -167,7 +170,26 @@ def _create_streaming(
     ):
         start_time = time.time()
         state = _ResponsesStreamState()
-        response = self._original.create(**kwargs)
+        try:
+            response = self._original.create(**kwargs)
+        except Exception as exc:
+            try:
+                self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    state,
+                    time.time() - start_time,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         def generator():
             stream_error: Optional[BaseException] = None
@@ -395,7 +417,26 @@ def _create_streaming(
             **(stream_options if isinstance(stream_options, dict) else {}),
             "include_usage": True,
         }
-        response = self._original.create(**kwargs)
+        try:
+            response = self._original.create(**kwargs)
+        except Exception as exc:
+            try:
+                self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    state,
+                    time.time() - start_time,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         def generator():
             stream_error: Optional[BaseException] = None
diff --git a/posthog/ai/openai/openai_async.py b/posthog/ai/openai/openai_async.py
index a37aebb6a..3d105f7a2 100644
--- a/posthog/ai/openai/openai_async.py
+++ b/posthog/ai/openai/openai_async.py
@@ -1,3 +1,4 @@
+import logging
 import time
 import uuid
 from typing import TYPE_CHECKING as _TYPE_CHECKING, Any, Dict, Optional
@@ -42,6 +43,8 @@
     merge_provider_override,
 )
 
+_log = logging.getLogger("posthog")
+
 
 class AsyncOpenAI(openai.AsyncOpenAI):
     """
@@ -168,7 +171,26 @@ async def _create_streaming(
     ):
         start_time = time.time()
         state = _ResponsesStreamState()
-        response = await self._original.create(**kwargs)
+        try:
+            response = await self._original.create(**kwargs)
+        except Exception as exc:
+            try:
+                await self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    state,
+                    time.time() - start_time,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         async def async_generator():
             stream_error: Optional[BaseException] = None
@@ -399,7 +421,26 @@ async def _create_streaming(
             **(stream_options if isinstance(stream_options, dict) else {}),
             "include_usage": True,
         }
-        response = await self._original.create(**kwargs)
+        try:
+            response = await self._original.create(**kwargs)
+        except Exception as exc:
+            try:
+                await self._capture_streaming_event(
+                    posthog_distinct_id,
+                    posthog_trace_id,
+                    posthog_properties,
+                    posthog_privacy_mode,
+                    posthog_groups,
+                    kwargs,
+                    state,
+                    time.time() - start_time,
+                    error=exc,
+                )
+            except Exception:
+                # Telemetry must never replace the provider's own error, and the
+                # fixed text avoids echoing prompt or error content into logs.
+                _log.warning("[PostHog] Failed to capture streaming connect error")
+            raise
 
         async def async_generator():
             stream_error: Optional[BaseException] = None
diff --git a/posthog/test/ai/test_stream_midstream_error.py b/posthog/test/ai/test_stream_midstream_error.py
index 386573a85..620b5990c 100644
--- a/posthog/test/ai/test_stream_midstream_error.py
+++ b/posthog/test/ai/test_stream_midstream_error.py
@@ -269,6 +269,168 @@ async def stream():
     assert props["$ai_http_status"] == 0
 
 
+class _ConnectError(RuntimeError):
+    status_code = 401
+
+
+def test_openai_chat_stream_connect_error(mock_client):
+    from posthog.ai.openai import OpenAI
+
+    with patch("openai.resources.chat.completions.Completions.create") as create:
+        create.side_effect = _ConnectError("bad key")
+        client = OpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "user", "content": "hi"}],
+                stream=True,
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+@pytest.mark.asyncio
+async def test_openai_chat_stream_connect_error_async(mock_client):
+    from posthog.ai.openai import AsyncOpenAI
+
+    async def create(**kwargs):
+        raise _ConnectError("bad key")
+
+    with patch(
+        "openai.resources.chat.completions.AsyncCompletions.create", side_effect=create
+    ):
+        client = AsyncOpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "user", "content": "hi"}],
+                stream=True,
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+def test_openai_responses_stream_connect_error(mock_client):
+    from posthog.ai.openai import OpenAI
+
+    with patch("openai.resources.responses.Responses.create") as create:
+        create.side_effect = _ConnectError("bad key")
+        client = OpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.responses.create(model="gpt-4", input="hi", stream=True)
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+@pytest.mark.asyncio
+async def test_openai_responses_stream_connect_error_async(mock_client):
+    from posthog.ai.openai import AsyncOpenAI
+
+    async def create(**kwargs):
+        raise _ConnectError("bad key")
+
+    with patch("openai.resources.responses.AsyncResponses.create", side_effect=create):
+        client = AsyncOpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.responses.create(model="gpt-4", input="hi", stream=True)
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+def test_anthropic_stream_connect_error(mock_client):
+    from posthog.ai.anthropic import Anthropic
+
+    with patch("anthropic.resources.messages.Messages.create") as create:
+        create.side_effect = _ConnectError("bad key")
+        client = Anthropic(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.messages.create(
+                model="claude-3-opus-20240229",
+                messages=[{"role": "user", "content": "hi"}],
+                max_tokens=5,
+                stream=True,
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+@pytest.mark.asyncio
+async def test_anthropic_stream_connect_error_async(mock_client):
+    from posthog.ai.anthropic import AsyncAnthropic
+
+    async def create(**kwargs):
+        raise _ConnectError("bad key")
+
+    with patch("anthropic.resources.messages.AsyncMessages.create", side_effect=create):
+        client = AsyncAnthropic(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.messages.create(
+                model="claude-3-opus-20240229",
+                messages=[{"role": "user", "content": "hi"}],
+                max_tokens=5,
+                stream=True,
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+def test_gemini_stream_connect_error(mock_client):
+    pytest.importorskip("google.genai")
+    from google import genai as google_genai
+
+    from posthog.ai.gemini import Client
+
+    with patch.object(google_genai, "Client") as cls:
+        inst = MagicMock()
+        cls.return_value = inst
+        inst.models.generate_content_stream.side_effect = _ConnectError("bad key")
+        client = Client(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.models.generate_content_stream(
+                model="gemini-2.0-flash", contents=["hi"]
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
+@pytest.mark.asyncio
+async def test_gemini_stream_connect_error_async(mock_client):
+    pytest.importorskip("google.genai")
+    from google import genai as google_genai
+
+    from posthog.ai.gemini import AsyncClient
+
+    with patch.object(google_genai, "Client") as cls:
+        inst = MagicMock()
+        cls.return_value = inst
+        inst.aio.models.generate_content_stream = AsyncMock(
+            side_effect=_ConnectError("bad key")
+        )
+        client = AsyncClient(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.models.generate_content_stream(
+                model="gemini-2.0-flash", contents=["hi"]
+            )
+
+    props = _props(mock_client)
+    assert props["$ai_is_error"] is True
+    assert props["$ai_http_status"] == 401
+
+
 @pytest.mark.parametrize(
     ("cls_name", "code"), [("ClientError", 429), ("ServerError", 503)]
 )
@@ -283,3 +445,88 @@ def test_capture_streaming_event_records_google_genai_error_status(
     props = _props(mock_client)
     assert props["$ai_http_status"] == code
     assert props["$ai_is_error"] is True
+
+
+def test_anthropic_stream_connect_error_survives_unformattable_input(mock_client):
+    from posthog.ai.anthropic import Anthropic
+
+    with patch("anthropic.resources.messages.Messages.create") as create:
+        create.side_effect = _ConnectError("bad request")
+        client = Anthropic(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.messages.create(
+                model="claude-3-opus-20240229",
+                messages=[None],
+                max_tokens=5,
+                stream=True,
+            )
+
+
+@pytest.mark.asyncio
+async def test_anthropic_stream_connect_error_survives_unformattable_input_async(
+    mock_client,
+):
+    from posthog.ai.anthropic import AsyncAnthropic
+
+    async def create(**kwargs):
+        raise _ConnectError("bad request")
+
+    with patch("anthropic.resources.messages.AsyncMessages.create", side_effect=create):
+        client = AsyncAnthropic(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.messages.create(
+                model="claude-3-opus-20240229",
+                messages=[None],
+                max_tokens=5,
+                stream=True,
+            )
+
+
+def test_openai_chat_stream_connect_error_survives_unformattable_input(mock_client):
+    from posthog.ai.openai import OpenAI
+
+    with patch("openai.resources.chat.completions.Completions.create") as create:
+        create.side_effect = _ConnectError("bad request")
+        client = OpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            client.chat.completions.create(model="gpt-4", messages=123, stream=True)
+
+
+@pytest.mark.asyncio
+async def test_openai_chat_stream_connect_error_survives_unformattable_input_async(
+    mock_client,
+):
+    from posthog.ai.openai import AsyncOpenAI
+
+    async def create(**kwargs):
+        raise _ConnectError("bad request")
+
+    with patch(
+        "openai.resources.chat.completions.AsyncCompletions.create", side_effect=create
+    ):
+        client = AsyncOpenAI(api_key="k", posthog_client=mock_client)
+        with pytest.raises(_ConnectError):
+            await client.chat.completions.create(
+                model="gpt-4", messages=123, stream=True
+            )
+
+
+def test_anthropic_connect_error_fallback_does_not_log_error_text(mock_client, caplog):
+    from posthog.ai.anthropic import Anthropic
+
+    with patch("anthropic.resources.messages.Messages.create") as create:
+        create.side_effect = _ConnectError("rejected PRIVATE_CANARY")
+        client = Anthropic(api_key="k", posthog_client=mock_client)
+        with caplog.at_level("DEBUG", logger="posthog"):
+            with pytest.raises(_ConnectError):
+                client.messages.create(
+                    model="claude-3-opus-20240229",
+                    messages=[None],
+                    max_tokens=5,
+                    stream=True,
+                    posthog_privacy_mode=True,
+                )
+
+    assert "Failed to capture streaming connect error" in caplog.text
+    assert "PRIVATE_CANARY" not in caplog.text
+    assert all(r.exc_info is None for r in caplog.records)

From a2ba575a2d19ae2527df48ce9cd4d148b16b0b7d Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 14:53:38 +0000
Subject: [PATCH 218/245] chore: Release v7.86.4 [skip ci]

---
 .sampo/changesets/stream-connect-error.md | 5 -----
 openfeature-provider/CHANGELOG.md         | 6 ++++++
 openfeature-provider/pyproject.toml       | 2 +-
 posthog/CHANGELOG.md                      | 6 ++++++
 posthog/version.py                        | 2 +-
 pyproject.toml                            | 2 +-
 uv.lock                                   | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/stream-connect-error.md

diff --git a/.sampo/changesets/stream-connect-error.md b/.sampo/changesets/stream-connect-error.md
deleted file mode 100644
index 9f684067b..000000000
--- a/.sampo/changesets/stream-connect-error.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Capture an `$ai_generation` error event when `create(stream=True)` fails before the stream starts (bad key, rate limit, invalid model) in the OpenAI chat, OpenAI Responses, Anthropic and Gemini wrappers, sync and async. Previously only errors raised mid-stream were captured.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 7da0053f6..5b42f3197 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.154 — 2026-11-09
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.4
+
 ## 0.1.153 — 2026-11-09
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3691bd186..3ac82efef 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.153"
+version = "0.1.154"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index d60f82cbc..03cab71b3 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.86.4 — 2026-11-09
+
+### Patch changes
+
+- [2c35f047](https://github.com/posthog/posthog-python/commit/2c35f0472a45b809e7b024a31edf1c85c60a391a) Capture an `$ai_generation` error event when `create(stream=True)` fails before the stream starts (bad key, rate limit, invalid model) in the OpenAI chat, OpenAI Responses, Anthropic and Gemini wrappers, sync and async. Previously only errors raised mid-stream were captured. — Thanks @pcbeingused333!
+
 ## 7.86.3 — 2026-11-09
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index cd62ba152..1a69694b2 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.3"
+VERSION = "7.86.4"
diff --git a/pyproject.toml b/pyproject.toml
index ccf96813e..ccbbe2b7f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.3"
+version = "7.86.4"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 8cfdfce7f..0eec9f592 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2670,7 +2670,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.153"
+version = "0.1.154"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3227,7 +3227,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.3"
+version = "7.86.4"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From c78e7bb7c5438df632fec2137c0bce16c4225590 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Mon, 9 Nov 2026 14:53:43 +0000
Subject: [PATCH 219/245] Update generated references

---
 .../posthog-python-references-7.86.4.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.4.json

diff --git a/references/posthog-python-references-7.86.4.json b/references/posthog-python-references-7.86.4.json
new file mode 100644
index 000000000..587faa0ba
--- /dev/null
+++ b/references/posthog-python-references-7.86.4.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.4",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 2ed52742a..587faa0ba 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.3",
+    "version": "7.86.4",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 133d7d12c3f15b04287b6d8389b0412fb7dfe6de Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Mon, 9 Nov 2026 18:33:38 +0100
Subject: [PATCH 220/245] test(compliance): expose the legacy payload accessor
 to the harness (#1179)

---
 .github/workflows/sdk-compliance.yml      |  4 +-
 sdk_compliance_adapter/CONTRIBUTING.md    |  2 +-
 sdk_compliance_adapter/README.md          |  1 +
 sdk_compliance_adapter/adapter.py         | 37 ++++++++++++++++
 sdk_compliance_adapter/docker-compose.yml |  2 +-
 sdk_compliance_adapter/test_adapter.py    | 54 ++++++++++++++++++++++-
 6 files changed, 94 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/sdk-compliance.yml b/.github/workflows/sdk-compliance.yml
index 02d787e64..7e72514a8 100644
--- a/.github/workflows/sdk-compliance.yml
+++ b/.github/workflows/sdk-compliance.yml
@@ -33,7 +33,7 @@ jobs:
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile"
       adapter-context: "."
-      test-harness-version: "1.23.0"
+      test-harness-version: "1.28.0"
       continue-on-error: false
       report-name: "sdk-compliance-report-v0"
 
@@ -43,6 +43,6 @@ jobs:
     with:
       adapter-dockerfile: "sdk_compliance_adapter/Dockerfile.v1"
       adapter-context: "."
-      test-harness-version: "1.23.0"
+      test-harness-version: "1.28.0"
       continue-on-error: false
       report-name: "sdk-compliance-report-v1"
diff --git a/sdk_compliance_adapter/CONTRIBUTING.md b/sdk_compliance_adapter/CONTRIBUTING.md
index 3033609b3..8514a342c 100644
--- a/sdk_compliance_adapter/CONTRIBUTING.md
+++ b/sdk_compliance_adapter/CONTRIBUTING.md
@@ -44,7 +44,7 @@ docker run -d --name sdk-adapter --network test-network -p 8080:8080 posthog-pyt
 docker run --rm \
   --name test-harness \
   --network test-network \
-  ghcr.io/posthog/sdk-test-harness:1.1.1 \
+  ghcr.io/posthog/sdk-test-harness:1.28.0 \
   run --adapter-url http://sdk-adapter:8080 --mock-url http://test-harness:8081
 
 # Cleanup
diff --git a/sdk_compliance_adapter/README.md b/sdk_compliance_adapter/README.md
index eae25916b..b35a0b1f7 100644
--- a/sdk_compliance_adapter/README.md
+++ b/sdk_compliance_adapter/README.md
@@ -25,6 +25,7 @@ The adapter implements the standard SDK adapter interface defined in the [test h
 - `POST /flush` - Flush pending events
 - `GET /state` - Return internal state
 - `POST /get_feature_flag` - Evaluate a flag locally or remotely
+- `POST /get_feature_flag_payload` - Read a flag payload locally or remotely with the legacy payload accessor
 - `POST /reload_feature_flag_definitions` - Fresh, bounded definitions readiness barrier
 - `POST /reset` - Reset SDK state
 
diff --git a/sdk_compliance_adapter/adapter.py b/sdk_compliance_adapter/adapter.py
index d205d1792..4dd0c25b3 100644
--- a/sdk_compliance_adapter/adapter.py
+++ b/sdk_compliance_adapter/adapter.py
@@ -313,6 +313,8 @@ def health():
     capabilities.append("feature_flags_local_evaluation_v1")
     # Remote /flags requests send ?v=4 and read the v4 flag record.
     capabilities.append("flags_response_v4")
+    # The legacy payload accessor is exposed on /get_feature_flag_payload.
+    capabilities.append("feature_flag_payloads")
     return jsonify(
         {
             "sdk_name": "posthog-python",
@@ -710,6 +712,41 @@ def get_feature_flag():
         return jsonify({"error": str(e)}), 500
 
 
+@app.route("/get_feature_flag_payload", methods=["POST"])
+def get_feature_flag_payload():
+    """Read a flag's payload with the legacy payload accessor.
+
+    Takes the same evaluation modes as /get_feature_flag; remote by default.
+    """
+    try:
+        if not state.client:
+            return jsonify({"error": "SDK not initialized"}), 400
+        data = request.json or {}
+        only_evaluate_locally = data.get("only_evaluate_locally", False)
+        force_remote = data.get("force_remote", not only_evaluate_locally)
+        if only_evaluate_locally and force_remote:
+            return jsonify(
+                {"error": "only_evaluate_locally conflicts with force_remote"}
+            ), 400
+        if not data.get("key") or not data.get("distinct_id"):
+            return jsonify({"error": "key and distinct_id are required"}), 400
+        client = (state.remote_client or state.client) if force_remote else state.client
+        payload = client.get_feature_flag_payload(
+            data["key"],
+            data["distinct_id"],
+            person_properties=data.get("person_properties"),
+            groups=data.get("groups"),
+            group_properties=data.get("group_properties"),
+            disable_geoip=data.get("disable_geoip"),
+            only_evaluate_locally=not force_remote,
+        )
+        client.flush()
+        return jsonify({"success": True, "value": payload})
+    except Exception as e:
+        logger.exception("Error reading feature flag payload")
+        return jsonify({"error": str(e)}), 500
+
+
 @app.route("/reset", methods=["POST"])
 def reset():
     """Reset SDK state"""
diff --git a/sdk_compliance_adapter/docker-compose.yml b/sdk_compliance_adapter/docker-compose.yml
index c679f5c4f..dcbd677de 100644
--- a/sdk_compliance_adapter/docker-compose.yml
+++ b/sdk_compliance_adapter/docker-compose.yml
@@ -23,7 +23,7 @@ services:
 
   # Test harness
   test-harness:
-    image: ghcr.io/posthog/sdk-test-harness:1.1.1
+    image: ghcr.io/posthog/sdk-test-harness:1.28.0
     command: ["run", "--adapter-url", "http://sdk-adapter:8080", "--mock-url", "http://test-harness:8081"]
     networks:
       - test-network
diff --git a/sdk_compliance_adapter/test_adapter.py b/sdk_compliance_adapter/test_adapter.py
index 0f40f20fc..8867b6ae9 100644
--- a/sdk_compliance_adapter/test_adapter.py
+++ b/sdk_compliance_adapter/test_adapter.py
@@ -87,6 +87,7 @@ def test_health_opts_into_local_evaluation_without_losing_capture(
     capabilities = adapter.app.test_client().get("/health").json["capabilities"]
     assert "feature_flags_local_evaluation_v1" in capabilities
     assert "flags_response_v4" in capabilities
+    assert "feature_flag_payloads" in capabilities
     assert capability in capabilities
     assert "capture_ai_v0" in capabilities
 
@@ -181,10 +182,59 @@ def test_force_remote_bypasses_loaded_local_definitions(adapter, monkeypatch):
     remote.assert_called_once()
 
 
-def test_rejects_conflicting_evaluation_modes(adapter):
+def test_payload_route_reads_remotely_and_returns_the_parsed_payload(
+    adapter, monkeypatch
+):
     client = initialize(adapter)
+    remote = Mock(
+        return_value=posthog.client.normalize_flags_response(
+            {
+                "featureFlags": {"flag": True},
+                "featureFlagPayloads": {"flag": '{"columns": 2}'},
+            }
+        )
+    )
+    monkeypatch.setattr(adapter.state.remote_client, "_get_flags_decision", remote)
     response = client.post(
-        "/get_feature_flag",
+        "/get_feature_flag_payload", json={"key": "flag", "distinct_id": "user"}
+    )
+    assert response.json == {"success": True, "value": {"columns": 2}}
+    remote.assert_called_once()
+    assert (
+        client.post("/get_feature_flag_payload", json={"key": "flag"}).status_code
+        == 400
+    )
+
+
+def test_payload_route_honors_local_only_evaluation(adapter, monkeypatch):
+    client = initialize(adapter)
+    local = definitions()
+    local["flags"][0]["filters"]["payloads"] = {"true": '{"columns": 2}'}
+    monkeypatch.setattr(
+        posthog.client, "get", Mock(return_value=GetResponse(data=local))
+    )
+    client.post("/reload_feature_flag_definitions", json={})
+    remote = Mock(side_effect=AssertionError("Local-only must never request /flags"))
+    monkeypatch.setattr(adapter.state.client, "_get_flags_decision", remote)
+    monkeypatch.setattr(adapter.state.remote_client, "_get_flags_decision", remote)
+    response = client.post(
+        "/get_feature_flag_payload",
+        json={
+            "key": "flag",
+            "distinct_id": "user",
+            "person_properties": {"plan": "banana"},
+            "only_evaluate_locally": True,
+        },
+    )
+    assert response.json == {"success": True, "value": {"columns": 2}}
+    remote.assert_not_called()
+
+
+@pytest.mark.parametrize("route", ["/get_feature_flag", "/get_feature_flag_payload"])
+def test_rejects_conflicting_evaluation_modes(adapter, route):
+    client = initialize(adapter)
+    response = client.post(
+        route,
         json={
             "key": "flag",
             "distinct_id": "user",

From 53770bc3a28e3436a75507d533fbde6063595044 Mon Sep 17 00:00:00 2001
From: Eli Reisman <eli.r@posthog.com>
Date: Mon, 9 Nov 2026 16:35:08 -0800
Subject: [PATCH 221/245] fix(celery): keep a task's own celery tags over
 propagated ones (#1209)

Tags propagated from the publishing task's context overrode the running
task's celery_* values, so events inside a child task, a retry or a
chord callback reported the publisher's task name, ID and retry count.
The task's own values now win. Other propagated tags are unchanged.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../changesets/celery-task-tag-merge-order.md |  5 ++
 posthog/integrations/celery.py                |  4 +-
 .../integrations/test_celery_integration.py   | 49 +++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/celery-task-tag-merge-order.md

diff --git a/.sampo/changesets/celery-task-tag-merge-order.md b/.sampo/changesets/celery-task-tag-merge-order.md
new file mode 100644
index 000000000..6bf1e2139
--- /dev/null
+++ b/.sampo/changesets/celery-task-tag-merge-order.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Events captured inside a Celery task now carry that task's own `celery_*` properties. Before, a task published from inside another task, such as a child task, a retry or a chord callback, reported the publishing task's `celery_task_name`, `celery_task_id` and `celery_retry_count`.
diff --git a/posthog/integrations/celery.py b/posthog/integrations/celery.py
index c11117922..0e37379f9 100644
--- a/posthog/integrations/celery.py
+++ b/posthog/integrations/celery.py
@@ -313,7 +313,9 @@ def _on_task_prerun(self, *args, **kwargs):
             self._apply_propagated_identity(request)
             self._enrich_task_span(task_id)
 
-            merged_tags = {**task_properties, **context_tags}
+            # The task's own celery_* values win: tags propagated from a task
+            # that published this one carry that task's values.
+            merged_tags = {**context_tags, **task_properties}
             for key, value in merged_tags.items():
                 contexts.tag(key, value)
 
diff --git a/posthog/test/integrations/test_celery_integration.py b/posthog/test/integrations/test_celery_integration.py
index 0e06314eb..9a4a7ad15 100644
--- a/posthog/test/integrations/test_celery_integration.py
+++ b/posthog/test/integrations/test_celery_integration.py
@@ -3,6 +3,8 @@
 from types import SimpleNamespace
 from unittest.mock import Mock, patch
 
+from parameterized import parameterized
+
 from posthog import contexts
 from posthog.integrations.celery import (
     CONTEXT_DISTINCT_ID_HEADER,
@@ -260,6 +262,53 @@ def test_before_task_publish_nested_headers_round_trips_to_worker(self):
         # close out the task lifecycle so the test doesn't leave context hanging around
         integration._on_task_success(sender=task)
 
+    @parameterized.expand(
+        [
+            # name, publishing task (name, id, retries), running task (name, id, retries)
+            ("child_task", ("app.parent", "parent-1", 0), ("app.child", "child-1", 0)),
+            ("retry", ("app.flaky", "flaky-1", 0), ("app.flaky", "flaky-1", 1)),
+            (
+                "chord_callback",
+                ("app.header", "header-1", 0),
+                ("app.callback", "callback-1", 0),
+            ),
+        ]
+    )
+    def test_task_published_from_a_task_keeps_its_own_celery_tags(
+        self, _name, publisher, worker
+    ):
+        integration = PosthogCeleryIntegration(client=Mock())
+
+        def run_task(name, task_id, retries, headers):
+            request = SimpleNamespace(
+                headers=headers, delivery_info={}, hostname="worker-1", retries=retries
+            )
+            task = SimpleNamespace(name=name, request=request)
+            integration._on_task_prerun(sender=task, task_id=task_id)
+            return task
+
+        publisher_task = run_task(
+            *publisher,
+            {
+                CONTEXT_DISTINCT_ID_HEADER: "user-1",
+                CONTEXT_TAGS_HEADER: '{"request_id": "abc"}',
+            },
+        )
+        headers = {}
+        integration._on_before_task_publish(sender=worker[0], headers=headers)
+        integration._on_task_success(sender=publisher_task)
+
+        worker_task = run_task(*worker, headers["headers"])
+        tags = contexts.get_tags()
+        integration._on_task_success(sender=worker_task)
+
+        worker_name, worker_id, worker_retries = worker
+        self.assertEqual(tags["celery_task_name"], worker_name)
+        self.assertEqual(tags["celery_task_id"], worker_id)
+        self.assertEqual(tags["celery_retry_count"], worker_retries)
+        # Other context still propagates from the publishing task.
+        self.assertEqual(tags["request_id"], "abc")
+
     def test_before_task_publish_respects_propagate_context_flag(self):
         integration = PosthogCeleryIntegration(propagate_context=False)
         headers = {}

From d572d0999ef553ddb5f6a8f36eb6d5e1c7c39b17 Mon Sep 17 00:00:00 2001
From: Eli Reisman <eli.r@posthog.com>
Date: Mon, 9 Nov 2026 16:36:52 -0800
Subject: [PATCH 222/245] fix: handle AsyncPosthog in the LangChain and
 new_context exception paths (#1211)

* fix(ai): send failed LangChain runs on AsyncPosthog

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(contexts): default new_context to no capture for AsyncPosthog

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../langchain-async-client-failed-runs.md     |  8 ++++++++
 posthog/ai/langchain/callbacks.py             |  6 +++---
 posthog/contexts.py                           |  2 +-
 posthog/test/ai/langchain/test_callbacks.py   | 20 +++++++++++++++++++
 posthog/test/test_contexts.py                 | 16 +++++++++++++++
 5 files changed, 48 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/langchain-async-client-failed-runs.md

diff --git a/.sampo/changesets/langchain-async-client-failed-runs.md b/.sampo/changesets/langchain-async-client-failed-runs.md
new file mode 100644
index 000000000..689dcd083
--- /dev/null
+++ b/.sampo/changesets/langchain-async-client-failed-runs.md
@@ -0,0 +1,8 @@
+---
+pypi/posthog: patch
+---
+
+`AsyncPosthog` no longer breaks two exception paths that read `enable_exception_autocapture`, a setting `AsyncPosthog` does not have:
+
+- The LangChain callback handler no longer loses a failed run's `$ai_generation`, `$ai_span` or `$ai_trace` event. LangChain swallowed the error, so the event was never sent. The failed event is now sent without an `$exception`.
+- `new_context(client=<AsyncPosthog>)` no longer raises `AttributeError`. Without `capture_exceptions`, it now leaves exceptions uncaptured; pass `capture_exceptions=True` to capture them.
diff --git a/posthog/ai/langchain/callbacks.py b/posthog/ai/langchain/callbacks.py
index e94d843e8..f670d6794 100644
--- a/posthog/ai/langchain/callbacks.py
+++ b/posthog/ai/langchain/callbacks.py
@@ -593,9 +593,9 @@ def _capture_exception_and_update_properties(
         self, exception: BaseException, event_properties: Dict[str, Any]
     ) -> Dict[str, Any]:
         # An `$exception` event carries the message and stack, which echo prompts and output.
-        if not self._ph_client.enable_exception_autocapture or _privacy_mode_enabled(
-            self._ph_client, self._privacy_mode
-        ):
+        if not getattr(
+            self._ph_client, "enable_exception_autocapture", False
+        ) or _privacy_mode_enabled(self._ph_client, self._privacy_mode):
             return event_properties
 
         exception_id = self._ph_client.capture_exception(
diff --git a/posthog/contexts.py b/posthog/contexts.py
index 36ec8adaa..4acdf8abb 100644
--- a/posthog/contexts.py
+++ b/posthog/contexts.py
@@ -173,7 +173,7 @@ def _get_active_span_context() -> Dict[str, Optional[str]]:
 
 def _default_capture_exceptions(client: Optional["Client"] = None) -> bool:
     if client is not None:
-        return client.enable_exception_autocapture
+        return getattr(client, "enable_exception_autocapture", False)
 
     from . import default_client, enable_exception_autocapture
 
diff --git a/posthog/test/ai/langchain/test_callbacks.py b/posthog/test/ai/langchain/test_callbacks.py
index b4ae495e8..68103a5a0 100644
--- a/posthog/test/ai/langchain/test_callbacks.py
+++ b/posthog/test/ai/langchain/test_callbacks.py
@@ -2808,6 +2808,26 @@ def failing_span(_):
     assert span_props["$ai_error"] == "ValueError: test error"
 
 
+def test_exception_autocapture_absent_on_client_still_sends_the_span():
+    """A client without the autocapture setting, such as AsyncPosthog, still gets the failed span."""
+    mock_client = MagicMock(spec=["capture", "capture_exception", "privacy_mode"])
+    mock_client.privacy_mode = False
+
+    def failing_span(_):
+        raise ValueError("test error")
+
+    callbacks = [CallbackHandler(mock_client)]
+    with pytest.raises(ValueError):
+        RunnableLambda(failing_span).invoke({}, config={"callbacks": callbacks})
+
+    assert mock_client.capture_exception.call_count == 0
+    assert mock_client.capture.call_count == 1
+    span_props = mock_client.capture.call_args[1]["properties"]
+    assert span_props["$ai_is_error"] is True
+    assert span_props["$ai_error"] == "ValueError: test error"
+    assert "$exception_event_id" not in span_props
+
+
 @pytest.mark.parametrize(
     "autocapture, client_privacy_mode, handler_privacy_mode, expected_error",
     [
diff --git a/posthog/test/test_contexts.py b/posthog/test/test_contexts.py
index e75a6610d..b8c57e96c 100644
--- a/posthog/test/test_contexts.py
+++ b/posthog/test/test_contexts.py
@@ -5,6 +5,7 @@
 from unittest.mock import MagicMock, patch
 
 import posthog
+from posthog.async_client import AsyncPosthog
 from posthog.client import Client
 from posthog.contexts import (
     get_tags,
@@ -227,6 +228,21 @@ def test_new_context_defaults_to_custom_client_exception_autocapture_disabled(se
 
         client.capture_exception.assert_not_called()
 
+    def test_new_context_with_async_client_defaults_to_no_exception_capture(self):
+        client = AsyncPosthog("phc_test", disabled=True)
+        client.capture_exception = MagicMock()
+
+        with self.assertRaises(RuntimeError):
+            with new_context(client=client):
+                raise RuntimeError("Context exception")
+        client.capture_exception.assert_not_called()
+
+        test_exception = RuntimeError("Context exception")
+        with self.assertRaises(RuntimeError):
+            with new_context(client=client, capture_exceptions=True):
+                raise test_exception
+        client.capture_exception.assert_called_once_with(test_exception)
+
     def test_identify_context(self):
         with new_context(fresh=True):
             # Initially no distinct ID

From 65a3e9b4cf744eb958e8f58345fcd1988d5d88e2 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 10 Nov 2026 02:17:49 +0000
Subject: [PATCH 223/245] chore: Release v7.86.5 [skip ci]

---
 .sampo/changesets/celery-task-tag-merge-order.md       |  5 -----
 .../changesets/langchain-async-client-failed-runs.md   |  8 --------
 openfeature-provider/CHANGELOG.md                      |  6 ++++++
 openfeature-provider/pyproject.toml                    |  2 +-
 posthog/CHANGELOG.md                                   | 10 ++++++++++
 posthog/version.py                                     |  2 +-
 pyproject.toml                                         |  2 +-
 uv.lock                                                |  4 ++--
 8 files changed, 21 insertions(+), 18 deletions(-)
 delete mode 100644 .sampo/changesets/celery-task-tag-merge-order.md
 delete mode 100644 .sampo/changesets/langchain-async-client-failed-runs.md

diff --git a/.sampo/changesets/celery-task-tag-merge-order.md b/.sampo/changesets/celery-task-tag-merge-order.md
deleted file mode 100644
index 6bf1e2139..000000000
--- a/.sampo/changesets/celery-task-tag-merge-order.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Events captured inside a Celery task now carry that task's own `celery_*` properties. Before, a task published from inside another task, such as a child task, a retry or a chord callback, reported the publishing task's `celery_task_name`, `celery_task_id` and `celery_retry_count`.
diff --git a/.sampo/changesets/langchain-async-client-failed-runs.md b/.sampo/changesets/langchain-async-client-failed-runs.md
deleted file mode 100644
index 689dcd083..000000000
--- a/.sampo/changesets/langchain-async-client-failed-runs.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-pypi/posthog: patch
----
-
-`AsyncPosthog` no longer breaks two exception paths that read `enable_exception_autocapture`, a setting `AsyncPosthog` does not have:
-
-- The LangChain callback handler no longer loses a failed run's `$ai_generation`, `$ai_span` or `$ai_trace` event. LangChain swallowed the error, so the event was never sent. The failed event is now sent without an `$exception`.
-- `new_context(client=<AsyncPosthog>)` no longer raises `AttributeError`. Without `capture_exceptions`, it now leaves exceptions uncaptured; pass `capture_exceptions=True` to capture them.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 5b42f3197..c72800c3f 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.155 — 2026-11-10
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.5
+
 ## 0.1.154 — 2026-11-09
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 3ac82efef..10cd3fba3 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.154"
+version = "0.1.155"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 03cab71b3..e17ebd270 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,15 @@
 # posthog
 
+## 7.86.5 — 2026-11-10
+
+### Patch changes
+
+- [53770bc3](https://github.com/posthog/posthog-python/commit/53770bc3a28e3436a75507d533fbde6063595044) Events captured inside a Celery task now carry that task's own `celery_*` properties. Before, a task published from inside another task, such as a child task, a retry or a chord callback, reported the publishing task's `celery_task_name`, `celery_task_id` and `celery_retry_count`. — Thanks @eli-r-ph!
+- [d572d099](https://github.com/posthog/posthog-python/commit/d572d0999ef553ddb5f6a8f36eb6d5e1c7c39b17) `AsyncPosthog` no longer breaks two exception paths that read `enable_exception_autocapture`, a setting `AsyncPosthog` does not have:
+  
+  - The LangChain callback handler no longer loses a failed run's `$ai_generation`, `$ai_span` or `$ai_trace` event. LangChain swallowed the error, so the event was never sent. The failed event is now sent without an `$exception`.
+  - `new_context(client=<AsyncPosthog>)` no longer raises `AttributeError`. Without `capture_exceptions`, it now leaves exceptions uncaptured; pass `capture_exceptions=True` to capture them. — Thanks @eli-r-ph!
+
 ## 7.86.4 — 2026-11-09
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 1a69694b2..8b33cccf1 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.4"
+VERSION = "7.86.5"
diff --git a/pyproject.toml b/pyproject.toml
index ccbbe2b7f..61ef7effd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.4"
+version = "7.86.5"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 0eec9f592..13089db59 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2670,7 +2670,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.154"
+version = "0.1.155"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3227,7 +3227,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.4"
+version = "7.86.5"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 9b4639187df3818a24350c522146313c5864d4b6 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 10 Nov 2026 02:17:54 +0000
Subject: [PATCH 224/245] Update generated references

---
 .../posthog-python-references-7.86.5.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.5.json

diff --git a/references/posthog-python-references-7.86.5.json b/references/posthog-python-references-7.86.5.json
new file mode 100644
index 000000000..9ad33f5ee
--- /dev/null
+++ b/references/posthog-python-references-7.86.5.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.5",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 587faa0ba..9ad33f5ee 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.4",
+    "version": "7.86.5",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 9d154daecc9330b806d052a631547447df941941 Mon Sep 17 00:00:00 2001
From: Ioannis J <yiannis@posthog.com>
Date: Tue, 10 Nov 2026 11:25:18 +0200
Subject: [PATCH 225/245] ci: keep dependabot from raising uv/pip manifest
 floors (#1219)

---
 .github/dependabot.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 81fad45b2..565dbe6c0 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -27,6 +27,7 @@ updates:
       - dependency-name: "langchain*"
       - dependency-name: "langgraph"
     open-pull-requests-limit: 1
+    versioning-strategy: increase-if-necessary
     reviewers:
       - "PostHog/team-llm-analytics"
 
@@ -57,6 +58,7 @@ updates:
       - dependency-name: "langchain*"
       - dependency-name: "langgraph"
     open-pull-requests-limit: 1
+    versioning-strategy: increase-if-necessary
     reviewers:
       - "PostHog/team-llm-analytics"
     # Uncomment below to enable auto-merge for minor updates when CI passes

From 4d732304a94f06f12ad61ec538832c9a671ceeb1 Mon Sep 17 00:00:00 2001
From: alexcastgonz <82875882+pcbeingused333@users.noreply.github.com>
Date: Tue, 10 Nov 2026 08:52:00 -0400
Subject: [PATCH 226/245] fix(ai): report thinking tokens from the Anthropic
 wrapper (#1205)

* fix(ai): report thinking tokens from the Anthropic wrapper

Map usage.output_tokens_details.thinking_tokens to reasoning_tokens
($ai_reasoning_tokens) for non-streaming and streaming responses.
The streaming value is cumulative on message_delta, so it is replaced
rather than summed.

* fix(ai): emit reasoning tokens for Anthropic streaming events

capture_streaming_event copied only the cache fields for Anthropic and
skipped the shared optional-token path, so $ai_reasoning_tokens never
reached $ai_generation for streams.
---
 .../changesets/anthropic-thinking-tokens.md   |  5 ++
 posthog/ai/anthropic/_anthropic_stream.py     |  6 ++
 posthog/ai/anthropic/anthropic_converter.py   | 17 +++++
 posthog/ai/utils.py                           |  3 +
 posthog/test/ai/anthropic/test_anthropic.py   | 64 +++++++++++++++++++
 .../ai/anthropic/test_anthropic_converter.py  | 56 ++++++++++++++++
 6 files changed, 151 insertions(+)
 create mode 100644 .sampo/changesets/anthropic-thinking-tokens.md

diff --git a/.sampo/changesets/anthropic-thinking-tokens.md b/.sampo/changesets/anthropic-thinking-tokens.md
new file mode 100644
index 000000000..43a3dadc4
--- /dev/null
+++ b/.sampo/changesets/anthropic-thinking-tokens.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+The Anthropic wrapper now reports `$ai_reasoning_tokens` from `usage.output_tokens_details.thinking_tokens`, for both regular and streaming responses.
diff --git a/posthog/ai/anthropic/_anthropic_stream.py b/posthog/ai/anthropic/_anthropic_stream.py
index 2df160ef8..7c76cc369 100644
--- a/posthog/ai/anthropic/_anthropic_stream.py
+++ b/posthog/ai/anthropic/_anthropic_stream.py
@@ -62,6 +62,12 @@ def consume(self, event: Any) -> None:
                 # (server tools can emit several in one stream). Keep the
                 # latest total; a field the event omits leaves the prior one.
                 self.usage_stats["output_tokens"] = output_tokens
+            # thinking tokens on a message_delta are cumulative as well
+            thinking_tokens = extract_anthropic_usage_from_event(event).get(
+                "reasoning_tokens"
+            )
+            if thinking_tokens is not None:
+                self.usage_stats["reasoning_tokens"] = thinking_tokens
 
         if getattr(event, "type", None) == "content_block_start":
             block, tool = handle_anthropic_content_block_start(event)
diff --git a/posthog/ai/anthropic/anthropic_converter.py b/posthog/ai/anthropic/anthropic_converter.py
index 1e476c5c5..1ee525e72 100644
--- a/posthog/ai/anthropic/anthropic_converter.py
+++ b/posthog/ai/anthropic/anthropic_converter.py
@@ -242,6 +242,15 @@ def extract_anthropic_stop_reason(response: Any) -> Optional[str]:
     return getattr(response, "stop_reason", None)
 
 
+def _extract_thinking_tokens(usage: Any) -> int:
+    """Return usage.output_tokens_details.thinking_tokens (0 if absent or null)."""
+    details = getattr(usage, "output_tokens_details", None)
+    thinking = getattr(details, "thinking_tokens", None)
+    if isinstance(thinking, int) and not isinstance(thinking, bool):
+        return thinking
+    return 0
+
+
 def extract_anthropic_usage_from_response(response: Any) -> TokenUsage:
     """
     Extract usage from a full Anthropic response (non-streaming).
@@ -273,6 +282,10 @@ def extract_anthropic_usage_from_response(response: Any) -> TokenUsage:
         if cache_creation and cache_creation > 0:
             result["cache_creation_input_tokens"] = cache_creation
 
+    thinking_tokens = _extract_thinking_tokens(response.usage)
+    if thinking_tokens > 0:
+        result["reasoning_tokens"] = thinking_tokens
+
     web_search_count = extract_anthropic_web_search_count(response)
     if web_search_count > 0:
         result["web_search_count"] = web_search_count
@@ -319,6 +332,10 @@ def extract_anthropic_usage_from_event(event: Any) -> TokenUsage:
     if hasattr(event, "usage") and event.usage:
         usage["output_tokens"] = getattr(event.usage, "output_tokens", 0)
 
+        thinking_tokens = _extract_thinking_tokens(event.usage)
+        if thinking_tokens > 0:
+            usage["reasoning_tokens"] = thinking_tokens
+
         # Extract web search count from usage
         if hasattr(event.usage, "server_tool_use"):
             server_tool_use = event.usage.server_tool_use
diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py
index 779ea705e..874ff3fcb 100644
--- a/posthog/ai/utils.py
+++ b/posthog/ai/utils.py
@@ -1147,6 +1147,9 @@ def capture_streaming_event(
         cache_creation = event_data["usage_stats"].get("cache_creation_input_tokens", 0)
         event_properties["$ai_cache_read_input_tokens"] = cache_read
         event_properties["$ai_cache_creation_input_tokens"] = cache_creation
+        reasoning = event_data["usage_stats"].get("reasoning_tokens")
+        if isinstance(reasoning, int) and reasoning > 0:
+            event_properties["$ai_reasoning_tokens"] = reasoning
     else:
         optional_token_fields = [
             "cache_read_input_tokens",
diff --git a/posthog/test/ai/anthropic/test_anthropic.py b/posthog/test/ai/anthropic/test_anthropic.py
index ffc6feeed..d14847a94 100644
--- a/posthog/test/ai/anthropic/test_anthropic.py
+++ b/posthog/test/ai/anthropic/test_anthropic.py
@@ -907,6 +907,70 @@ async def mock_async_create(**kwargs):
     assert_cumulative_delta_usage(mock_client.capture.call_args.kwargs["properties"])
 
 
+def anthropic_stream_with_thinking_tokens():
+    from types import SimpleNamespace
+
+    events = anthropic_stream_with_server_tool_usage()
+    events[1] = SimpleNamespace(
+        type="message_delta",
+        delta=events[1].delta,
+        usage=SimpleNamespace(
+            input_tokens=10,
+            output_tokens=110,
+            cache_creation_input_tokens=0,
+            cache_read_input_tokens=0,
+            server_tool_use=None,
+            output_tokens_details=SimpleNamespace(thinking_tokens=40),
+        ),
+    )
+    return events
+
+
+def test_streaming_reports_thinking_tokens_as_reasoning_tokens(mock_client):
+    with patch(
+        "anthropic.resources.Messages.create",
+        return_value=iter(anthropic_stream_with_thinking_tokens()),
+    ):
+        client = Anthropic(api_key="test-key", posthog_client=mock_client)
+        response = client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        list(response)
+
+    props = mock_client.capture.call_args.kwargs["properties"]
+    assert props["$ai_output_tokens"] == 110
+    assert props["$ai_reasoning_tokens"] == 40
+
+
+@pytest.mark.asyncio
+async def test_streaming_reports_thinking_tokens_as_reasoning_tokens_async(
+    mock_client,
+):
+    async def mock_async_stream():
+        for event in anthropic_stream_with_thinking_tokens():
+            yield event
+
+    async def mock_async_create(**kwargs):
+        return mock_async_stream()
+
+    with patch(
+        "anthropic.resources.messages.AsyncMessages.create",
+        side_effect=mock_async_create,
+    ):
+        client = AsyncAnthropic(api_key="test-key", posthog_client=mock_client)
+        response = await client.messages.create(
+            model="claude-haiku-4-5",
+            messages=[{"role": "user", "content": "Hello"}],
+            stream=True,
+        )
+        [event async for event in response]
+
+    props = mock_client.capture.call_args.kwargs["properties"]
+    assert props["$ai_reasoning_tokens"] == 40
+
+
 def anthropic_stream_with_two_cumulative_deltas():
     # Server tools can emit more than one message_delta in a single stream,
     # and each delta's usage is cumulative: later values replace earlier ones
diff --git a/posthog/test/ai/anthropic/test_anthropic_converter.py b/posthog/test/ai/anthropic/test_anthropic_converter.py
index 15aaeaa6c..aef31a03a 100644
--- a/posthog/test/ai/anthropic/test_anthropic_converter.py
+++ b/posthog/test/ai/anthropic/test_anthropic_converter.py
@@ -157,3 +157,59 @@ def test_streaming_thinking_deltas_accumulate():
             ],
         }
     ]
+
+
+def test_response_usage_maps_thinking_tokens_to_reasoning_tokens():
+    from types import SimpleNamespace
+
+    from posthog.ai.anthropic.anthropic_converter import (
+        extract_anthropic_usage_from_response,
+    )
+
+    response = SimpleNamespace(
+        usage=SimpleNamespace(
+            input_tokens=10,
+            output_tokens=50,
+            output_tokens_details=SimpleNamespace(thinking_tokens=30),
+        ),
+        content=[],
+    )
+    usage = extract_anthropic_usage_from_response(response)
+    assert usage["output_tokens"] == 50
+    assert usage["reasoning_tokens"] == 30
+
+
+def test_response_usage_null_output_tokens_details_is_absent():
+    from types import SimpleNamespace
+
+    from posthog.ai.anthropic.anthropic_converter import (
+        extract_anthropic_usage_from_response,
+    )
+
+    response = SimpleNamespace(
+        usage=SimpleNamespace(
+            input_tokens=10, output_tokens=50, output_tokens_details=None
+        ),
+        content=[],
+    )
+    assert "reasoning_tokens" not in extract_anthropic_usage_from_response(response)
+
+
+def test_stream_message_delta_thinking_tokens_not_double_counted():
+    from types import SimpleNamespace
+
+    from posthog.ai.anthropic._anthropic_stream import _AnthropicStreamAccumulator
+
+    acc = _AnthropicStreamAccumulator()
+    for output, thinking in [(20, 10), (50, 30)]:
+        acc.consume(
+            SimpleNamespace(
+                type="message_delta",
+                usage=SimpleNamespace(
+                    output_tokens=output,
+                    output_tokens_details=SimpleNamespace(thinking_tokens=thinking),
+                ),
+            )
+        )
+    assert acc.usage_stats["output_tokens"] == 50
+    assert acc.usage_stats["reasoning_tokens"] == 30

From 1342bb0bac0de26c81bcef95206a2a3db36b9025 Mon Sep 17 00:00:00 2001
From: peterolkhov <peter@useprox.com>
Date: Tue, 10 Nov 2026 07:52:24 -0500
Subject: [PATCH 227/245] fix(exception-capture): normalize NaN rate-limit
 settings (#1210)

---
 .sampo/changesets/resolute-queen-loviatar.md |  5 +++
 posthog/bucketed_rate_limiter.py             |  7 +++-
 posthog/test/test_bucketed_rate_limiter.py   | 32 ++++++++++++++++
 posthog/test/test_exception_capture.py       | 40 ++++++++++++++++++++
 4 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 .sampo/changesets/resolute-queen-loviatar.md

diff --git a/.sampo/changesets/resolute-queen-loviatar.md b/.sampo/changesets/resolute-queen-loviatar.md
new file mode 100644
index 000000000..74a3ab7b9
--- /dev/null
+++ b/.sampo/changesets/resolute-queen-loviatar.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Treat NaN exception rate-limit settings as invalid numbers so autocapture keeps working and bucket limits remain finite.
diff --git a/posthog/bucketed_rate_limiter.py b/posthog/bucketed_rate_limiter.py
index 7cf24be90..0bd7549cc 100644
--- a/posthog/bucketed_rate_limiter.py
+++ b/posthog/bucketed_rate_limiter.py
@@ -3,6 +3,7 @@
 # Kept behaviorally identical so rate limiting is consistent across SDKs.
 
 import logging
+import math
 import threading
 import time
 from typing import Callable, Dict, Hashable, Optional, Union
@@ -15,7 +16,11 @@
 
 
 def _clamp_to_range(value, min_value: Number, max_value: Number, label: str) -> Number:
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or (isinstance(value, float) and math.isnan(value))
+    ):
         log.warning(f"{label} must be a number. Using max value {max_value}.")
         return max_value
     if value > max_value:
diff --git a/posthog/test/test_bucketed_rate_limiter.py b/posthog/test/test_bucketed_rate_limiter.py
index 93ec96dc8..95e46184a 100644
--- a/posthog/test/test_bucketed_rate_limiter.py
+++ b/posthog/test/test_bucketed_rate_limiter.py
@@ -199,6 +199,38 @@ def test_clamps_out_of_range_options():
     assert limiter._refill_interval == 86400.0
 
 
+@pytest.mark.parametrize(
+    "option, attribute, fallback",
+    [
+        ("bucket_size", "_bucket_size", 100),
+        ("refill_rate", "_refill_rate", 10),
+        ("refill_interval_seconds", "_refill_interval", 86400.0),
+    ],
+)
+def test_nan_options_use_invalid_number_fallback(option, attribute, fallback, caplog):
+    limiter = make_limiter(FakeClock(), **{option: float("nan")})
+
+    assert getattr(limiter, attribute) == fallback
+    assert f"{option} must be a number" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        (0, 0),
+        (10**1000, 100),
+        (float("inf"), 100),
+        (float("-inf"), 0),
+        (True, 100),
+        (False, 100),
+    ],
+)
+def test_bucket_size_preserves_existing_clamping(value, expected):
+    limiter = make_limiter(FakeClock(), bucket_size=value)
+
+    assert limiter._bucket_size == expected
+
+
 def test_thread_safety_allows_exactly_bucket_size_minus_one():
     limiter = make_limiter(FakeClock(), bucket_size=50)
     allowed = []
diff --git a/posthog/test/test_exception_capture.py b/posthog/test/test_exception_capture.py
index a8ca09ff4..e491b606e 100644
--- a/posthog/test/test_exception_capture.py
+++ b/posthog/test/test_exception_capture.py
@@ -92,6 +92,46 @@ def test_client_passes_rate_limiter_configuration_through():
         client.shutdown()
 
 
+@pytest.mark.parametrize(
+    "option, attempts, expected_uploads",
+    [
+        ("exception_autocapture_refill_interval_seconds", 6, 2),
+        ("exception_autocapture_bucket_size", 105, 99),
+    ],
+)
+def test_nan_limiter_configuration_keeps_exception_hook_working(
+    monkeypatch, caplog, option, attempts, expected_uploads
+):
+    from posthog import Posthog
+
+    previous_hook = MagicMock()
+    upload = MagicMock()
+    monkeypatch.setattr(sys, "excepthook", previous_hook)
+    monkeypatch.setattr("posthog.client.batch_post", upload)
+    options = {
+        "exception_autocapture_bucket_size": 3,
+        "exception_autocapture_refill_interval_seconds": 60,
+        option: float("nan"),
+    }
+    client = Posthog(
+        "phc_test",
+        sync_mode=True,
+        enable_exception_autocapture=True,
+        enable_exception_autocapture_rate_limiting=True,
+        **options,
+    )
+    try:
+        for _ in range(attempts):
+            error = ValueError("boom")
+            sys.excepthook(type(error), error, None)
+
+        assert upload.call_count == expected_uploads
+        assert previous_hook.call_count == attempts
+        assert "Failed to capture exception" not in caplog.text
+    finally:
+        client.shutdown()
+
+
 def test_rate_limits_per_exception_type():
     from posthog.exception_capture import ExceptionCapture
 

From 8c6b328d3440409887636ccd96d6e19b9825eb55 Mon Sep 17 00:00:00 2001
From: Luan Taraschi <130802253+luantaraschi@users.noreply.github.com>
Date: Tue, 10 Nov 2026 09:53:56 -0300
Subject: [PATCH 228/245] fix(flags): clamp relative month and year lookbacks
 after every step (#1212)

Month and year lookbacks jumped straight to the target and clamped once. The SDK spec requires one unit at a time with a clamp after every step, so 2m on March 31 is January 28, and 4y on February 29 is February 28.
---
 .../relative-date-clamp-every-step.md         |  5 +++
 posthog/feature_flags.py                      | 16 ++++++---
 posthog/test/test_feature_flags.py            | 34 +++++++++++++++++++
 3 files changed, 51 insertions(+), 4 deletions(-)
 create mode 100644 .sampo/changesets/relative-date-clamp-every-step.md

diff --git a/.sampo/changesets/relative-date-clamp-every-step.md b/.sampo/changesets/relative-date-clamp-every-step.md
new file mode 100644
index 000000000..e6e89f7a1
--- /dev/null
+++ b/.sampo/changesets/relative-date-clamp-every-step.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Local evaluation of relative date filters now clamps the day after every month or year subtracted, as the SDK spec requires. A `2m` filter evaluated on March 31 resolved to January 31 and now resolves to January 28, and `4y` on February 29 resolves to February 28 of the target year.
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index 6a16ee319..bf10cf946 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -1609,14 +1609,20 @@ def parse_datetime(value: str) -> datetime.datetime:
 
 
 # Python's stdlib doesn't provide a calendar-aware month/year delta.
-# Clamp the day to the target month's end to match dateutil.relativedelta behavior.
+# Subtract one unit at a time and clamp the day after every step, so March 31
+# minus two months is January 28 (through February 28), as the SDK spec requires.
 def _subtract_months(dt: datetime.datetime, months: int) -> Optional[datetime.datetime]:
-    month_index = dt.year * 12 + dt.month - 1 - months
+    current_index = dt.year * 12 + dt.month - 1
+    month_index = current_index - months
     year = month_index // 12
     month = month_index % 12 + 1
     if not 1 <= year <= 9999:
         return None
-    day = min(dt.day, calendar.monthrange(year, month)[1])
+    day = dt.day
+    for index in range(current_index - 1, month_index - 1, -1):
+        if day <= 28:  # Every month has at least 28 days, so nothing clamps further.
+            break
+        day = min(day, calendar.monthrange(index // 12, index % 12 + 1)[1])
     return dt.replace(year=year, month=month, day=day)
 
 
@@ -1624,7 +1630,9 @@ def _subtract_years(dt: datetime.datetime, years: int) -> Optional[datetime.date
     year = dt.year - years
     if not 1 <= year <= 9999:
         return None
-    day = min(dt.day, calendar.monthrange(year, dt.month)[1])
+    # The year before a leap year is never a leap year, so February 29 clamps on
+    # the first step and stays on the 28th.
+    day = 28 if years > 0 and (dt.month, dt.day) == (2, 29) else dt.day
     return dt.replace(year=year, day=day)
 
 
diff --git a/posthog/test/test_feature_flags.py b/posthog/test/test_feature_flags.py
index ff1d56593..a18592db4 100644
--- a/posthog/test/test_feature_flags.py
+++ b/posthog/test/test_feature_flags.py
@@ -7247,6 +7247,40 @@ def test_year_parsing_clamps_to_target_month_end(self):
                 "1y"
             ) == now - relativedelta(years=1)
 
+    def test_month_parsing_clamps_after_every_step(self):
+        cases = [
+            ("2025-03-31T12:00:00Z", "2m", (2025, 1, 28)),
+            ("2024-03-31T12:00:00Z", "2m", (2024, 1, 29)),
+            ("2025-05-31T12:00:00Z", "2m", (2025, 3, 30)),
+            ("2025-05-31T12:00:00Z", "4m", (2025, 1, 28)),
+            ("2025-01-31T12:00:00Z", "11m", (2024, 2, 29)),
+            ("2025-03-30T12:00:00Z", "13m", (2024, 2, 28)),
+        ]
+        for now, value, expected in cases:
+            with self.subTest(now=now, value=value), freeze_time(now):
+                assert relative_date_parse_for_feature_flag_matching(
+                    value
+                ) == datetime.datetime(*expected, 12, tzinfo=datetime.timezone.utc)
+
+    def test_year_parsing_clamps_after_every_step(self):
+        cases = [
+            ("2024-02-29T12:00:00Z", "4y", (2020, 2, 28)),
+            ("2024-02-29T12:00:00Z", "2y", (2022, 2, 28)),
+            ("2024-03-31T12:00:00Z", "4y", (2020, 3, 31)),
+            ("2024-02-28T12:00:00Z", "4y", (2020, 2, 28)),
+        ]
+        for now, value, expected in cases:
+            with self.subTest(now=now, value=value), freeze_time(now):
+                assert relative_date_parse_for_feature_flag_matching(
+                    value
+                ) == datetime.datetime(*expected, 12, tzinfo=datetime.timezone.utc)
+
+    def test_month_and_year_parsing_with_zero_keeps_the_date(self):
+        with freeze_time("2024-02-29T12:00:00Z"):
+            now = datetime.datetime.now(datetime.timezone.utc)
+            assert relative_date_parse_for_feature_flag_matching("0m") == now
+            assert relative_date_parse_for_feature_flag_matching("0y") == now
+
     def test_year_parsing(self):
         with freeze_time("2020-01-01T12:01:20.1340Z"):
             assert relative_date_parse_for_feature_flag_matching(

From b5dbdcec8ee17fb0241f1ad5a9fb3aeb2225847e Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 10 Nov 2026 13:03:32 +0000
Subject: [PATCH 229/245] chore: Release v7.86.6 [skip ci]

---
 .sampo/changesets/anthropic-thinking-tokens.md      | 5 -----
 .sampo/changesets/relative-date-clamp-every-step.md | 5 -----
 .sampo/changesets/resolute-queen-loviatar.md        | 5 -----
 openfeature-provider/CHANGELOG.md                   | 6 ++++++
 openfeature-provider/pyproject.toml                 | 2 +-
 posthog/CHANGELOG.md                                | 8 ++++++++
 posthog/version.py                                  | 2 +-
 pyproject.toml                                      | 2 +-
 uv.lock                                             | 4 ++--
 9 files changed, 19 insertions(+), 20 deletions(-)
 delete mode 100644 .sampo/changesets/anthropic-thinking-tokens.md
 delete mode 100644 .sampo/changesets/relative-date-clamp-every-step.md
 delete mode 100644 .sampo/changesets/resolute-queen-loviatar.md

diff --git a/.sampo/changesets/anthropic-thinking-tokens.md b/.sampo/changesets/anthropic-thinking-tokens.md
deleted file mode 100644
index 43a3dadc4..000000000
--- a/.sampo/changesets/anthropic-thinking-tokens.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-The Anthropic wrapper now reports `$ai_reasoning_tokens` from `usage.output_tokens_details.thinking_tokens`, for both regular and streaming responses.
diff --git a/.sampo/changesets/relative-date-clamp-every-step.md b/.sampo/changesets/relative-date-clamp-every-step.md
deleted file mode 100644
index e6e89f7a1..000000000
--- a/.sampo/changesets/relative-date-clamp-every-step.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Local evaluation of relative date filters now clamps the day after every month or year subtracted, as the SDK spec requires. A `2m` filter evaluated on March 31 resolved to January 31 and now resolves to January 28, and `4y` on February 29 resolves to February 28 of the target year.
diff --git a/.sampo/changesets/resolute-queen-loviatar.md b/.sampo/changesets/resolute-queen-loviatar.md
deleted file mode 100644
index 74a3ab7b9..000000000
--- a/.sampo/changesets/resolute-queen-loviatar.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Treat NaN exception rate-limit settings as invalid numbers so autocapture keeps working and bucket limits remain finite.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index c72800c3f..03831c80a 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.156 — 2026-11-10
+
+### Patch changes
+
+- Updated dependencies: posthog@7.86.6
+
 ## 0.1.155 — 2026-11-10
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index 10cd3fba3..d874d5eb2 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.155"
+version = "0.1.156"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index e17ebd270..ec254cb54 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,13 @@
 # posthog
 
+## 7.86.6 — 2026-11-10
+
+### Patch changes
+
+- [4d732304](https://github.com/posthog/posthog-python/commit/4d732304a94f06f12ad61ec538832c9a671ceeb1) The Anthropic wrapper now reports `$ai_reasoning_tokens` from `usage.output_tokens_details.thinking_tokens`, for both regular and streaming responses. — Thanks @pcbeingused333!
+- [1342bb0b](https://github.com/posthog/posthog-python/commit/1342bb0bac0de26c81bcef95206a2a3db36b9025) Treat NaN exception rate-limit settings as invalid numbers so autocapture keeps working and bucket limits remain finite. — Thanks @peterolkhov for your first contribution 🎉!
+- [8c6b328d](https://github.com/posthog/posthog-python/commit/8c6b328d3440409887636ccd96d6e19b9825eb55) Local evaluation of relative date filters now clamps the day after every month or year subtracted, as the SDK spec requires. A `2m` filter evaluated on March 31 resolved to January 31 and now resolves to January 28, and `4y` on February 29 resolves to February 28 of the target year. — Thanks @luantaraschi!
+
 ## 7.86.5 — 2026-11-10
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 8b33cccf1..5ded7edab 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.5"
+VERSION = "7.86.6"
diff --git a/pyproject.toml b/pyproject.toml
index 61ef7effd..590cd3a91 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.5"
+version = "7.86.6"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 13089db59..91ca4f896 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2670,7 +2670,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.155"
+version = "0.1.156"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3227,7 +3227,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.5"
+version = "7.86.6"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 1f185fd20a2b57d16486170f50cf436e01a54506 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Tue, 10 Nov 2026 13:03:38 +0000
Subject: [PATCH 230/245] Update generated references

---
 .../posthog-python-references-7.86.6.json     | 3572 +++++++++++++++++
 .../posthog-python-references-latest.json     |    2 +-
 2 files changed, 3573 insertions(+), 1 deletion(-)
 create mode 100644 references/posthog-python-references-7.86.6.json

diff --git a/references/posthog-python-references-7.86.6.json b/references/posthog-python-references-7.86.6.json
new file mode 100644
index 000000000..bb1993e71
--- /dev/null
+++ b/references/posthog-python-references-7.86.6.json
@@ -0,0 +1,3572 @@
+{
+  "id": "posthog-python",
+  "hogRef": "0.3",
+  "info": {
+    "version": "7.86.6",
+    "id": "posthog-python",
+    "title": "PostHog Python SDK",
+    "description": "Integrate PostHog into any python application.",
+    "slugPrefix": "posthog-python",
+    "specUrl": "https://github.com/PostHog/posthog-python"
+  },
+  "types": [
+    {
+      "id": "FeatureFlag",
+      "name": "FeatureFlag",
+      "path": "posthog.types.FeatureFlag",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[FlagReason]",
+          "description": "Field: reason"
+        },
+        {
+          "name": "metadata",
+          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
+          "description": "Field: metadata"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FeatureFlagResult",
+      "name": "FeatureFlagResult",
+      "path": "posthog.types.FeatureFlagResult",
+      "properties": [
+        {
+          "name": "key",
+          "type": "str",
+          "description": "Field: key"
+        },
+        {
+          "name": "enabled",
+          "type": "bool",
+          "description": "Field: enabled"
+        },
+        {
+          "name": "variant",
+          "type": "Optional[str]",
+          "description": "Field: variant"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[Any]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "reason",
+          "type": "Optional[str]",
+          "description": "Field: reason"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagMetadata",
+      "name": "FlagMetadata",
+      "path": "posthog.types.FlagMetadata",
+      "properties": [
+        {
+          "name": "id",
+          "type": "Optional[int]",
+          "description": "Field: id"
+        },
+        {
+          "name": "payload",
+          "type": "Optional[str]",
+          "description": "Field: payload"
+        },
+        {
+          "name": "version",
+          "type": "Optional[int]",
+          "description": "Field: version"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        },
+        {
+          "name": "has_experiment",
+          "type": "Optional[bool]",
+          "description": "Field: has_experiment"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagReason",
+      "name": "FlagReason",
+      "path": "posthog.types.FlagReason",
+      "properties": [
+        {
+          "name": "code",
+          "type": "str",
+          "description": "Field: code"
+        },
+        {
+          "name": "condition_index",
+          "type": "Optional[int]",
+          "description": "Field: condition_index"
+        },
+        {
+          "name": "description",
+          "type": "str",
+          "description": "Field: description"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsAndPayloads",
+      "name": "FlagsAndPayloads",
+      "path": "posthog.types.FlagsAndPayloads",
+      "properties": [
+        {
+          "name": "featureFlags",
+          "type": "Optional[dict[str, Union[bool, str]]]",
+          "description": "Field: featureFlags"
+        },
+        {
+          "name": "featureFlagPayloads",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: featureFlagPayloads"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "FlagsResponse",
+      "name": "FlagsResponse",
+      "path": "posthog.types.FlagsResponse",
+      "properties": [
+        {
+          "name": "flags",
+          "type": "dict[str, FeatureFlag]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "errorsWhileComputingFlags",
+          "type": "bool",
+          "description": "Field: errorsWhileComputingFlags"
+        },
+        {
+          "name": "requestId",
+          "type": "str",
+          "description": "Field: requestId"
+        },
+        {
+          "name": "quotaLimit",
+          "type": "Optional[list[str]]",
+          "description": "Field: quotaLimit"
+        },
+        {
+          "name": "evaluatedAt",
+          "type": "Optional[int]",
+          "description": "Field: evaluatedAt"
+        },
+        {
+          "name": "minimalFlagCalledEvents",
+          "type": "bool",
+          "description": "Field: minimalFlagCalledEvents"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "LegacyFlagMetadata",
+      "name": "LegacyFlagMetadata",
+      "path": "posthog.types.LegacyFlagMetadata",
+      "properties": [
+        {
+          "name": "payload",
+          "type": "Any",
+          "description": "Field: payload"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalCaptureArgs",
+      "name": "OptionalCaptureArgs",
+      "path": "posthog.args.OptionalCaptureArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "groups",
+          "type": "NotRequired[Optional[dict[str, str]]]",
+          "description": "Field: groups"
+        },
+        {
+          "name": "flags",
+          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
+          "description": "Field: flags"
+        },
+        {
+          "name": "send_feature_flags",
+          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
+          "description": "Field: send_feature_flags"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        },
+        {
+          "name": "_property_allowlist",
+          "type": "NotRequired[Optional[frozenset[str]]]",
+          "description": "Field: _property_allowlist"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "OptionalSetArgs",
+      "name": "OptionalSetArgs",
+      "path": "posthog.args.OptionalSetArgs",
+      "properties": [
+        {
+          "name": "distinct_id",
+          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
+          "description": "Field: distinct_id"
+        },
+        {
+          "name": "properties",
+          "type": "NotRequired[Optional[dict[str, Any]]]",
+          "description": "Field: properties"
+        },
+        {
+          "name": "timestamp",
+          "type": "NotRequired[Union[datetime, str, any]]",
+          "description": "Field: timestamp"
+        },
+        {
+          "name": "uuid",
+          "type": "NotRequired[Union[str, UUID, any]]",
+          "description": "Field: uuid"
+        },
+        {
+          "name": "disable_geoip",
+          "type": "NotRequired[Optional[bool]]",
+          "description": "Field: disable_geoip"
+        }
+      ],
+      "example": ""
+    },
+    {
+      "id": "SendFeatureFlagsOptions",
+      "name": "SendFeatureFlagsOptions",
+      "path": "posthog.types.SendFeatureFlagsOptions",
+      "properties": [
+        {
+          "name": "should_send",
+          "type": "bool",
+          "description": "Field: should_send"
+        },
+        {
+          "name": "only_evaluate_locally",
+          "type": "Optional[bool]",
+          "description": "Field: only_evaluate_locally"
+        },
+        {
+          "name": "person_properties",
+          "type": "Optional[dict[str, Any]]",
+          "description": "Field: person_properties"
+        },
+        {
+          "name": "group_properties",
+          "type": "Optional[dict[str, dict[str, Any]]]",
+          "description": "Field: group_properties"
+        },
+        {
+          "name": "flag_keys_filter",
+          "type": "Optional[list[str]]",
+          "description": "Field: flag_keys_filter"
+        }
+      ],
+      "example": ""
+    }
+  ],
+  "classes": [
+    {
+      "id": "PostHog",
+      "title": "PostHog",
+      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
+      "functions": [
+        {
+          "id": "__init__",
+          "title": "Client",
+          "description": "Initialize a new PostHog client instance.",
+          "details": "",
+          "category": "Initialization",
+          "params": [
+            {
+              "name": "project_api_key",
+              "description": "PostHog project API key/token.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "host",
+              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "debug",
+              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_queue_size",
+              "description": "Maximum number of events buffered before upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "send",
+              "description": "If False, queueing succeeds but events are not sent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "on_error",
+              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flush_at",
+              "description": "Number of queued events that triggers a batch upload.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "flush_interval",
+              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "gzip",
+              "description": "Whether to gzip event upload payloads.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "max_retries",
+              "description": "Number of upload retries. Values below 0 are treated as 0.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "sync_mode",
+              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "timeout",
+              "description": "HTTP request timeout in seconds for event uploads.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "thread",
+              "description": "Number of background consumer threads.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "poll_interval",
+              "description": "Seconds between local feature flag definition refreshes.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "personal_api_key",
+              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "disabled",
+              "description": "If True, disable captures and API requests. Useful in tests.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "is_server",
+              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "historical_migration",
+              "description": "Mark events as historical migration imports.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "feature_flags_request_timeout_seconds",
+              "description": "Timeout in seconds for feature         flag and remote config requests.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "feature_flags_request_max_retries",
+              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "super_properties",
+              "description": "Properties merged into every captured event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_exception_autocapture",
+              "description": "Automatically capture uncaught         exceptions.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "log_captured_exceptions",
+              "description": "Also log exceptions captured by error         tracking.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "project_root",
+              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "privacy_mode",
+              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "before_send",
+              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "flag_fallback_cache_url",
+              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "enable_local_evaluation",
+              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "flag_definition_cache_provider",
+              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
+              "isOptional": true,
+              "type": "FlagDefinitionCacheProvider"
+            },
+            {
+              "name": "capture_exception_code_variables",
+              "description": "Capture local variable values on         exception stack frames.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "code_variables_mask_patterns",
+              "description": "Variable-name patterns to mask when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_ignore_patterns",
+              "description": "Variable-name patterns to omit when         capturing code variables.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_mask_url_credentials",
+              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "code_variables_detect_secrets",
+              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "in_app_modules",
+              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
+              "isOptional": false,
+              "type": "UnionType[list[str], any]"
+            },
+            {
+              "name": "enable_exception_autocapture_rate_limiting",
+              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "exception_autocapture_bucket_size",
+              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_rate",
+              "description": "Tokens restored per refill         interval for each exception type's bucket.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "exception_autocapture_refill_interval_seconds",
+              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "capture_mode",
+              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
+              "isOptional": false,
+              "type": "CaptureMode"
+            },
+            {
+              "name": "capture_compression",
+              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
+              "isOptional": false,
+              "type": "CaptureCompression"
+            },
+            {
+              "name": "secret_key",
+              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
+              "isOptional": false,
+              "type": "any"
+            },
+            {
+              "name": "metrics",
+              "description": "",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "enable_full_ai_capture",
+              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_trace_context",
+              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_use_ai_lane",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "_enable_multimodal_capture",
+              "description": "",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "traces",
+              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
+              "isOptional": true,
+              "type": "dict"
+            },
+            {
+              "name": "app_host",
+              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "email_request_timeout_seconds",
+              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
+              "isOptional": false,
+              "type": "float"
+            },
+            {
+              "name": "email_request_max_retries",
+              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
+              "isOptional": false,
+              "type": "int"
+            },
+            {
+              "name": "migrated_from",
+              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
+            }
+          ]
+        },
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Create an alias between two distinct IDs.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to capture.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Anonymous event",
+              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
+            },
+            {
+              "id": "example_2",
+              "name": "Context usage",
+              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
+            },
+            {
+              "id": "example_3",
+              "name": "Set event properties",
+              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            },
+            {
+              "id": "example_4",
+              "name": "Page view event",
+              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Capture",
+          "params": [
+            {
+              "name": "event",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          }
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
+          "details": "",
+          "category": "Error Tracking",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture.",
+              "isOptional": true,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Check if a feature flag is enabled for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all feature flags for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flags and their payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get multivariate feature flag value for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload for a feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "The specific flag value to get payload for.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to only evaluate locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flags_and_payloads",
+          "title": "get_feature_flags_and_payloads",
+          "description": "Get feature flags and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_payloads",
+          "title": "get_feature_payloads",
+          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Optional[str]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_variants",
+          "title": "get_feature_variants",
+          "description": "Get feature flag variants for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Union[bool, str]]"
+          }
+        },
+        {
+          "id": "get_flags_decision",
+          "title": "get_flags_decision",
+          "description": "Get feature flags decision.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "A dictionary of group information.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "A dictionary of person properties.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "A dictionary of group properties.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this request.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "The device ID for this request.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsResponse"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "decision = posthog.get_flags_decision('user123')"
+            }
+          ]
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The remote config feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Identify a group and set its properties.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "A dictionary of properties to set on the group.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
+              "isOptional": false,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP for this event.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID of the user performing the action.",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.join()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flags for local evaluation.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.load_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the wrapped function using this client.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to create a fresh context that doesn't inherit from parent.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a person profile.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set with distinct id",
+              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a person profile only if they haven't been set before.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
+            }
+          ]
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
+          "details": "",
+          "category": null,
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog.shutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value.",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          }
+        }
+      ]
+    },
+    {
+      "id": "PostHogModule",
+      "title": "PostHog Module Functions",
+      "description": "Global functions available in the PostHog module",
+      "functions": [
+        {
+          "id": "alias",
+          "title": "alias",
+          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "previous_id",
+              "description": "The unique ID of the user before",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The current unique id",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Alias user",
+              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
+            }
+          ]
+        },
+        {
+          "id": "capture",
+          "title": "capture",
+          "description": "Capture anything a user does within your system.",
+          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Context and capture usage",
+              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
+            },
+            {
+              "id": "example_2",
+              "name": "Set event properties",
+              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_ai",
+          "title": "capture_ai",
+          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
+          "details": "",
+          "category": "Events",
+          "params": [
+            {
+              "name": "event",
+              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
+            }
+          ]
+        },
+        {
+          "id": "capture_exception",
+          "title": "capture_exception",
+          "description": "Capture exceptions that happen in your code.",
+          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
+          "category": "Events",
+          "params": [
+            {
+              "name": "exception",
+              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
+              "isOptional": false,
+              "type": "BaseException"
+            },
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalCaptureArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Capture exception",
+              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
+            }
+          ]
+        },
+        {
+          "id": "evaluate_flags",
+          "title": "evaluate_flags",
+          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
+              "isOptional": false,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "flag_keys",
+              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
+              "isOptional": true,
+              "type": "list[str]"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FeatureFlagEvaluations"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
+            }
+          ]
+        },
+        {
+          "id": "feature_enabled",
+          "title": "feature_enabled",
+          "description": "Use feature flags to enable or disable features for users.",
+          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[bool]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Boolean feature flag",
+              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "feature_flag_definitions",
+          "title": "feature_flag_definitions",
+          "description": "Returns loaded feature flags.",
+          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
+            }
+          ]
+        },
+        {
+          "id": "flush",
+          "title": "flush",
+          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
+          "details": "",
+          "category": "Client management",
+          "params": [
+            {
+              "name": "timeout_seconds",
+              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
+              "isOptional": true,
+              "type": "float"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
+            }
+          ]
+        },
+        {
+          "id": "get_active_span",
+          "title": "get_active_span",
+          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
+          "details": "",
+          "category": "Tracing",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[Span]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags",
+          "title": "get_all_flags",
+          "description": "Get all flags for a given user.",
+          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[dict[str, Union[bool, str]]]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "All flags for user",
+              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_all_flags_and_payloads",
+          "title": "get_all_flags_and_payloads",
+          "description": "Get all feature flag values and payloads for a user.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "flag_keys_to_evaluate",
+              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "FlagsAndPayloads"
+          }
+        },
+        {
+          "id": "get_feature_flag",
+          "title": "get_feature_flag",
+          "description": "Get feature flag variant for users. Used with experiments.",
+          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Groups mapping from group type to group key",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties in format { group_type_name: { group_properties } }",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send feature flag events",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Union[bool, str, any]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Multivariate feature flag",
+              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_evaluation_runtime",
+          "title": "get_feature_flag_evaluation_runtime",
+          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
+          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagEvaluationRuntime]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_keys_by_evaluation_runtime",
+          "title": "get_feature_flag_keys_by_evaluation_runtime",
+          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
+          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "evaluation_runtime",
+              "description": "",
+              "isOptional": true,
+              "type": "FeatureFlagEvaluationRuntime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "list[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
+            }
+          ]
+        },
+        {
+          "id": "get_feature_flag_payload",
+          "title": "get_feature_flag_payload",
+          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "match_value",
+              "description": "Optional flag value to use when selecting a payload.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[object]"
+          }
+        },
+        {
+          "id": "get_feature_flag_result",
+          "title": "get_feature_flag_result",
+          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The feature flag key.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "distinct_id",
+              "description": "The user's distinct ID.",
+              "isOptional": true,
+              "type": "Number"
+            },
+            {
+              "name": "groups",
+              "description": "Mapping of group type to group key.",
+              "isOptional": true,
+              "type": "Mapping[str, Union[str, int]]"
+            },
+            {
+              "name": "person_properties",
+              "description": "Person properties to use for evaluation.",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "group_properties",
+              "description": "Group properties keyed by group type.",
+              "isOptional": true,
+              "type": "dict[str, dict[str, Any]]"
+            },
+            {
+              "name": "only_evaluate_locally",
+              "description": "Whether to evaluate only locally.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "send_feature_flag_events",
+              "description": "Whether to send a $feature_flag_called event.",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "device_id",
+              "description": "Optional device ID override for experience-continuity flags.",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[FeatureFlagResult]"
+          }
+        },
+        {
+          "id": "get_remote_config_payload",
+          "title": "get_remote_config_payload",
+          "description": "Get the payload for a remote config feature flag.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "key",
+              "description": "The key of the feature flag",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "get_tags",
+          "title": "get_tags",
+          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
+          "details": "",
+          "category": "Contexts",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "dict[str, Any]"
+          }
+        },
+        {
+          "id": "group_identify",
+          "title": "group_identify",
+          "description": "Set properties on a group.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "group_type",
+              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "group_key",
+              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "properties",
+              "description": "Properties to set on the group",
+              "isOptional": true,
+              "type": "dict[str, Any]"
+            },
+            {
+              "name": "timestamp",
+              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
+              "isOptional": false,
+              "type": "datetime"
+            },
+            {
+              "name": "uuid",
+              "description": "Optional UUID for the event",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "disable_geoip",
+              "description": "Whether to disable GeoIP lookup",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "distinct_id",
+              "description": "Optional distinct ID of the user performing the action",
+              "isOptional": false,
+              "type": "Number"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Group identify",
+              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
+            }
+          ]
+        },
+        {
+          "id": "identify_context",
+          "title": "identify_context",
+          "description": "Identify the current context with a distinct ID.",
+          "details": "",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "distinct_id",
+              "description": "The distinct ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
+            }
+          ]
+        },
+        {
+          "id": "join",
+          "title": "join",
+          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import join\njoin()"
+            }
+          ]
+        },
+        {
+          "id": "load_feature_flags",
+          "title": "load_feature_flags",
+          "description": "Load feature flag definitions from PostHog.",
+          "details": "",
+          "category": "Feature flags",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import load_feature_flags\nload_feature_flags()"
+            }
+          ]
+        },
+        {
+          "id": "new_context",
+          "title": "new_context",
+          "description": "Create a new context scope that will be active for the duration of the with block.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            },
+            {
+              "name": "client",
+              "description": "Optional Posthog client instance to use for this context (default: None)",
+              "isOptional": true,
+              "type": "Client"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
+            }
+          ]
+        },
+        {
+          "id": "scoped",
+          "title": "scoped",
+          "description": "Decorator that creates a new context for the function.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "fresh",
+              "description": "Whether to start with a fresh context (default: False)",
+              "isOptional": false,
+              "type": "bool"
+            },
+            {
+              "name": "capture_exceptions",
+              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
+            }
+          ]
+        },
+        {
+          "id": "set",
+          "title": "set",
+          "description": "Set properties on a user record.",
+          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set person properties",
+              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
+            }
+          ]
+        },
+        {
+          "id": "set_capture_exception_code_variables_context",
+          "title": "set_capture_exception_code_variables_context",
+          "description": "Override code-variable capture for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_detect_secrets_context",
+          "title": "set_code_variables_detect_secrets_context",
+          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_ignore_patterns_context",
+          "title": "set_code_variables_ignore_patterns_context",
+          "description": "Override code-variable ignore patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "ignore_patterns",
+              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_patterns_context",
+          "title": "set_code_variables_mask_patterns_context",
+          "description": "Override code-variable mask patterns for exceptions in the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "mask_patterns",
+              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
+              "isOptional": true,
+              "type": "list[str]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_code_variables_mask_url_credentials_context",
+          "title": "set_code_variables_mask_url_credentials_context",
+          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
+          "details": "",
+          "category": null,
+          "params": [
+            {
+              "name": "enabled",
+              "description": "",
+              "isOptional": true,
+              "type": "bool"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          }
+        },
+        {
+          "id": "set_context_device_id",
+          "title": "set_context_device_id",
+          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "device_id",
+              "description": "The device ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_context_session",
+          "title": "set_context_session",
+          "description": "Set the session ID for the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "session_id",
+              "description": "The session ID to associate with the current context and its children",
+              "isOptional": true,
+              "type": "str"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
+            }
+          ]
+        },
+        {
+          "id": "set_once",
+          "title": "set_once",
+          "description": "Set properties on a user record, only if they do not yet exist.",
+          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
+          "category": "Identification",
+          "params": [
+            {
+              "name": "kwargs",
+              "description": "",
+              "isOptional": true,
+              "type": "Unpack[OptionalSetArgs]"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Optional[str]"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Set property once",
+              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
+            }
+          ]
+        },
+        {
+          "id": "setup",
+          "title": "setup",
+          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
+          "details": "",
+          "category": "Initialization",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Client"
+          }
+        },
+        {
+          "id": "shutdown",
+          "title": "shutdown",
+          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
+          "details": "",
+          "category": "Client management",
+          "params": [],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "any"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import shutdown\nshutdown()"
+            }
+          ]
+        },
+        {
+          "id": "start_span",
+          "title": "start_span",
+          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
+          "details": "",
+          "category": "Tracing",
+          "params": [
+            {
+              "name": "name",
+              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "kind",
+              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "attributes",
+              "description": "Initial attributes.",
+              "isOptional": true,
+              "type": "Mapping[str, Any]"
+            },
+            {
+              "name": "parent",
+              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
+              "isOptional": false,
+              "type": "Span"
+            },
+            {
+              "name": "tracestate",
+              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "start_time",
+              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
+              "isOptional": false,
+              "type": "datetime"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "Span"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
+            }
+          ]
+        },
+        {
+          "id": "tag",
+          "title": "tag",
+          "description": "Add a tag to the current context.",
+          "details": "",
+          "category": "Contexts",
+          "params": [
+            {
+              "name": "name",
+              "description": "The tag key",
+              "isOptional": true,
+              "type": "str"
+            },
+            {
+              "name": "value",
+              "description": "The tag value",
+              "isOptional": true,
+              "type": "Any"
+            }
+          ],
+          "showDocs": true,
+          "releaseTag": "public",
+          "returnType": {
+            "id": "return_type",
+            "name": "None"
+          },
+          "examples": [
+            {
+              "id": "example_1",
+              "name": "Example 1",
+              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "categories": [
+    "Initialization",
+    "Identification",
+    "Capture",
+    "Error Tracking",
+    "Feature flags",
+    "Tracing",
+    "Contexts",
+    "Events",
+    "Client management"
+  ]
+}
\ No newline at end of file
diff --git a/references/posthog-python-references-latest.json b/references/posthog-python-references-latest.json
index 9ad33f5ee..bb1993e71 100644
--- a/references/posthog-python-references-latest.json
+++ b/references/posthog-python-references-latest.json
@@ -2,7 +2,7 @@
   "id": "posthog-python",
   "hogRef": "0.3",
   "info": {
-    "version": "7.86.5",
+    "version": "7.86.6",
     "id": "posthog-python",
     "title": "PostHog Python SDK",
     "description": "Integrate PostHog into any python application.",

From 79f3559ca90bb157f3dce64b2b422b9d7c45eb0f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 10 Nov 2026 15:46:39 +0200
Subject: [PATCH 231/245] chore(deps): bump the github-actions group with 2
 updates (#1220)

Bumps the github-actions group with 2 updates: [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `github/codeql-action/init` from 4.39.1 to 4.39.2
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/9b3254085494b55a0f7c4c2b3d2d52cc712ce370...1fc58d04a4d4374f921bdac573c3811c240f9c26)

Updates `github/codeql-action/analyze` from 4.39.1 to 4.39.2
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/9b3254085494b55a0f7c4c2b3d2d52cc712ce370...1fc58d04a4d4374f921bdac573c3811c240f9c26)

---
updated-dependencies:
- dependency-name: github/codeql-action/init
  dependency-version: 4.39.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.39.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 8ad9f734f..b15388d96 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
+        uses: github/codeql-action/init@1fc58d04a4d4374f921bdac573c3811c240f9c26 # v4.39.2
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -40,6 +40,6 @@ jobs:
           trap-caching: false
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
+        uses: github/codeql-action/analyze@1fc58d04a4d4374f921bdac573c3811c240f9c26 # v4.39.2
         with:
           category: '/language:${{matrix.language}}'

From 08aac1d19c577aa127d59d1626963fde2552dff6 Mon Sep 17 00:00:00 2001
From: Ioannis J <yiannis@posthog.com>
Date: Tue, 10 Nov 2026 21:52:17 +0200
Subject: [PATCH 232/245] ci: notify Slack when release jobs fail, are
 cancelled, or never run (#1221)

* ci: notify Slack when release jobs fail, are cancelled, or never run

* ci: drop in-job Slack failure replies now covered by the notifier

* ci: accept a lone thread artifact and gate the notifier on trusted runs
---
 .../release-failure-notification.yml          |  59 ++++++++++
 .github/workflows/release.yml                 |  41 +++----
 RELEASING.md                                  |  10 ++
 scripts/release-failure-notification.cjs      | 103 ++++++++++++++++++
 4 files changed, 193 insertions(+), 20 deletions(-)
 create mode 100644 .github/workflows/release-failure-notification.yml
 create mode 100644 scripts/release-failure-notification.cjs

diff --git a/.github/workflows/release-failure-notification.yml b/.github/workflows/release-failure-notification.yml
new file mode 100644
index 000000000..caec2e759
--- /dev/null
+++ b/.github/workflows/release-failure-notification.yml
@@ -0,0 +1,59 @@
+name: Release failure notification
+
+on:
+  workflow_run:
+    workflows: [Release]
+    types: [completed]
+    branches: [main]
+
+permissions:
+  actions: read
+  contents: read
+
+jobs:
+  notify-failed:
+    name: Notify Slack - Failed
+    runs-on: ubuntu-latest
+    if: >-
+      github.event.workflow_run.head_repository.full_name == github.repository &&
+      (github.event.workflow_run.event == 'push' || github.event.workflow_run.event == 'workflow_dispatch')
+    timeout-minutes: 10
+    steps:
+      # This workflow must survive cancellation or runner startup failure in Release.
+      # Never execute code from the triggering run's head in this privileged workflow.
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          persist-credentials: false
+
+      - name: Download approval thread timestamps
+        continue-on-error: true
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8
+        with:
+          pattern: release-slack-thread-*
+          path: ${{ runner.temp }}/release-slack-threads
+          github-token: ${{ github.token }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Check release jobs
+        id: release-status
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        env:
+          SLACK_CHANNEL_ID: ${{ vars.SLACK_APPROVALS_CLIENT_LIBRARIES_CHANNEL_ID }}
+          THREAD_DIRECTORY: ${{ runner.temp }}/release-slack-threads
+        with:
+          retries: 3
+          script: |
+            const notification = require('./scripts/release-failure-notification.cjs');
+            const payload = await notification({ github, context, channel: process.env.SLACK_CHANNEL_ID, threadDirectory: process.env.THREAD_DIRECTORY });
+            if (payload) core.setOutput('payload', JSON.stringify(payload));
+
+      - name: Notify Slack - Failed
+        if: steps.release-status.outputs.payload != ''
+        uses: slackapi/slack-github-action@dcb1066f776dd043e64d0e8ba94ca15cc7e1875d # v4.0.0
+        with:
+          method: chat.postMessage
+          token: ${{ secrets.SLACK_CLIENT_LIBRARIES_BOT_TOKEN }}
+          errors: true
+          retries: 5
+          payload: ${{ steps.release-status.outputs.payload }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f644b94f9..e7d0fc916 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -53,6 +53,27 @@ jobs:
       slack_bot_token: ${{ secrets.SLACK_CLIENT_LIBRARIES_BOT_TOKEN }}
       posthog_project_api_key: ${{ secrets.POSTHOG_PROJECT_API_KEY }}
 
+  preserve-slack-thread:
+    name: Preserve Slack thread
+    needs: notify-approval-needed
+    if: needs.notify-approval-needed.outputs.slack_ts != ''
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    continue-on-error: true
+    permissions: {}
+    steps:
+      - name: Save approval thread timestamp
+        env:
+          THREAD_TS: ${{ needs.notify-approval-needed.outputs.slack_ts }}
+        run: printf '%s' "$THREAD_TS" > thread-ts.txt
+
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: release-slack-thread-${{ github.run_attempt }}
+          path: thread-ts.txt
+          retention-days: 30
+          if-no-files-found: error
+
   # Bump versions, commit to main, and regenerate references. This is the single
   # approval-gated job (environment "Release"). It does NOT publish — publishing
   # happens in the `publish` matrix job below, which has no environment so the
@@ -229,16 +250,6 @@ jobs:
               "alertContext": "The version bump/changelog step failed before packages were published."
             }
 
-      - name: Notify Slack - Failed
-        if: ${{ failure() && needs.notify-approval-needed.outputs.slack_ts != '' }}
-        uses: posthog/.github/.github/actions/slack-thread-reply@cb0979b67dcd585828b61ac45927eef4da8f6287 # main
-        with:
-          slack_bot_token: ${{ secrets.SLACK_CLIENT_LIBRARIES_BOT_TOKEN }}
-          slack_channel_id: ${{ vars.SLACK_APPROVALS_CLIENT_LIBRARIES_CHANNEL_ID }}
-          thread_ts: ${{ needs.notify-approval-needed.outputs.slack_ts }}
-          message: "❌ Failed to bump versions for `posthog-python@${{ steps.sampo-release.outputs.new_version }}`! <https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}|View logs>"
-          emoji_reaction: "x"
-
   # Build, publish, and tag each package whose version was bumped in this release.
   # A matrix over the publishable packages (N packages, like the posthog-ruby and
   # JS monorepos). The approval gate lives on `version-bump`, so this job has no
@@ -436,16 +447,6 @@ jobs:
               "alertContext": "The package publish step failed."
             }
 
-      - name: Notify Slack - Failed
-        if: ${{ failure() && needs.notify-approval-needed.outputs.slack_ts != '' }}
-        uses: posthog/.github/.github/actions/slack-thread-reply@cb0979b67dcd585828b61ac45927eef4da8f6287 # main
-        with:
-          slack_bot_token: ${{ secrets.SLACK_CLIENT_LIBRARIES_BOT_TOKEN }}
-          slack_channel_id: ${{ vars.SLACK_APPROVALS_CLIENT_LIBRARIES_CHANNEL_ID }}
-          thread_ts: ${{ needs.notify-approval-needed.outputs.slack_ts }}
-          message: "❌ Failed to publish `${{ matrix.package.name }}@${{ needs.version-bump.outputs.new_version }}`! <https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}|View logs>"
-          emoji_reaction: "x"
-
   # Side-effect-free rehearsal: runs ONLY when this workflow is manually
   # dispatched on a non-main branch (e.g. this PR branch). It applies the Sampo
   # version bump, builds openfeature-provider-posthog, and publishes it to
diff --git a/RELEASING.md b/RELEASING.md
index 568e9dd82..b2f7d9cd7 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -27,3 +27,13 @@ You can also trigger a release manually via the workflow's `workflow_dispatch` t
 
 > [!IMPORTANT]
 > Changesets must live in **`.sampo/changesets/`** (this is where `sampo add` puts them). Do **not** create them in the legacy `.changeset/` directory — Sampo and the `Release` workflow only read `.sampo/changesets/*.md`, so a changeset placed anywhere else is silently ignored and **no release is triggered**.
+
+## Failed or cancelled release
+
+The independent [release failure notification workflow](.github/workflows/release-failure-notification.yml) checks every completed `main` release attempt and alerts if a job failed, timed out, or was cancelled. This includes runner startup failures and cancellations with job records. It also alerts when the run did not succeed, no job failed, and a publish job (`Publish posthog`, `Publish posthoganalytics`, or `Publish openfeature-provider-posthog`) was never created, for example when GitHub Actions stops a run before the publish jobs start. Once every publish job succeeds, alerts describe follow-up problems rather than claiming the release failed, and the workflow alerts if the released Slack notification was skipped. It only acts on runs that a push or a manual dispatch started in this repository.
+
+Cancelled runs with no jobs are ignored, including superseded queued runs and manual cancellations before any job is created. A version-bump failure before any steps ran is also ignored when the rejection-reply step confirms an explicit rejection in the same attempt and no other job failed.
+
+Job inspection retries transient GitHub API failures up to three times. If inspection still fails, it logs the HTTP status or error type and message, then posts a fallback alert with the overall run status and logs link so the release can be checked manually. Error diagnostics stay in the run log, not in the Slack message.
+
+Alerts reply to the approval thread in the release approvals Slack channel. The release workflow preserves the thread timestamp in a run artifact for 30 days, independently of release approval. Failed-job reruns reuse the latest available thread from the same or an earlier attempt. If the timestamp is missing, invalid, or unavailable, the alert falls back to a new channel message, so it does not depend on the approval notification succeeding. The failure message surfaces Slack API errors rather than silently ignoring them. The notification workflow must be present on the default branch to run.
diff --git a/scripts/release-failure-notification.cjs b/scripts/release-failure-notification.cjs
new file mode 100644
index 000000000..8f5c9b265
--- /dev/null
+++ b/scripts/release-failure-notification.cjs
@@ -0,0 +1,103 @@
+const { readdirSync, readFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const unsuccessful = new Set(['failure', 'cancelled', 'timed_out', 'action_required', 'startup_failure', 'stale']);
+const publishJobs = ['Publish posthog', 'Publish posthoganalytics', 'Publish openfeature-provider-posthog'];
+
+const isJob = (job, name) => job.name === name || job.name.startsWith(`${name} (`);
+
+function readThreadTimestamp(directory, attempt) {
+    if (!directory) return undefined;
+    try {
+        const entries = readdirSync(directory);
+        // A single matching artifact is extracted straight into the directory.
+        // Failed-job reruns reuse the approval thread from the latest earlier attempt.
+        const files = entries.includes('thread-ts.txt')
+            ? [join(directory, 'thread-ts.txt')]
+            : entries
+                .map(name => /^release-slack-thread-(\d+)$/.exec(name)?.[1])
+                .filter(value => value && Number(value) <= attempt)
+                .sort((a, b) => Number(b) - Number(a))
+                .map(value => join(directory, `release-slack-thread-${value}`, 'thread-ts.txt'));
+        if (files.length === 0) return undefined;
+        const timestamp = readFileSync(files[0], 'utf8').trim();
+        return /^\d+\.\d+$/.test(timestamp) ? timestamp : undefined;
+    } catch (error) {
+        if (error.code !== 'ENOENT') console.error('Could not read Slack thread:', error.message);
+        return undefined;
+    }
+}
+
+module.exports = async function releaseFailureNotification({ github, context, channel, threadDirectory }) {
+    const run = context.payload.workflow_run;
+    const threadTs = readThreadTimestamp(threadDirectory, run.run_attempt);
+    const destination = { channel, ...(threadTs ? { thread_ts: threadTs } : {}) };
+    let jobs;
+    try {
+        jobs = await github.paginate(github.rest.actions.listJobsForWorkflowRunAttempt, {
+            ...context.repo,
+            run_id: run.id,
+            attempt_number: run.run_attempt,
+            per_page: 100,
+        });
+    } catch (error) {
+        console.error('Failed to inspect release jobs:', error.status ?? error.name, error.message);
+        return {
+            ...destination,
+            text: [
+                `⚠️ Could not inspect release jobs for \`${context.repo.owner}/${context.repo.repo}\` (attempt ${run.run_attempt}).`,
+                'Please check this release manually; individual job results are unavailable.',
+                `<${run.html_url}|View release logs> (run: ${run.conclusion})`,
+            ].join('\n'),
+            unfurl_links: false,
+            unfurl_media: false,
+        };
+    }
+
+    if (jobs.length === 0 && run.conclusion === 'cancelled') {
+        return null;
+    }
+
+    const failedJobs = jobs.filter(job => unsuccessful.has(job.conclusion));
+    const versionBump = jobs.find(job => job.name === 'Bump versions and commit to main');
+    if (run.conclusion === 'failure' && failedJobs.length === 1
+        && versionBump?.conclusion === 'failure' && versionBump.steps?.length === 0
+        && jobs.some(job => job.name === 'Notify Slack - Rejected'
+            && job.steps?.some(step => step.name === 'Notify Slack - Rejected' && step.conclusion === 'success'))) {
+        return null;
+    }
+
+    const pypiPublished = publishJobs.every(name => {
+        const cells = jobs.filter(job => isJob(job, name));
+        return cells.length > 0 && cells.every(job => job.conclusion === 'success');
+    });
+    const releasedNotification = jobs.find(job => job.name === 'Notify Slack - Released');
+    const problems = failedJobs.map(job => `• <${job.html_url}|${job.name}>: ${job.conclusion}`);
+
+    if (run.conclusion !== 'success' && failedJobs.length === 0) {
+        for (const name of publishJobs) {
+            if (!jobs.some(job => isJob(job, name))) problems.push(`• ${name}: never ran`);
+        }
+    }
+
+    if (pypiPublished && (!releasedNotification || releasedNotification.conclusion === 'skipped')) {
+        problems.push('• The released Slack notification did not run.');
+    }
+
+    if (problems.length === 0 && run.conclusion === 'success') {
+        return null;
+    }
+
+    return {
+        ...destination,
+        text: [
+            pypiPublished
+                ? `⚠️ PyPI packages published; follow-up problems for \`${context.repo.owner}/${context.repo.repo}\` (attempt ${run.run_attempt}).`
+                : `❌ Release process failed or was cancelled for \`${context.repo.owner}/${context.repo.repo}\` (attempt ${run.run_attempt}).`,
+            ...problems,
+            `<${run.html_url}|View release logs> (run: ${run.conclusion})`,
+        ].join('\n'),
+        unfurl_links: false,
+        unfurl_media: false,
+    };
+};

From 93fefa6649c63275292fc44c19902815d0ec9f5d Mon Sep 17 00:00:00 2001
From: "Vincent (Wen Yu) Ge" <29069505+gewenyu99@users.noreply.github.com>
Date: Tue, 10 Nov 2026 15:11:36 -0500
Subject: [PATCH 233/245] docs: add the Markdown reference adapter (#1182)

* docs: add the Markdown reference adapter

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: render the reference in one Python script

Drops the Node renderer, its tests, the page check and the sdk-specs
module. The generated pages are unchanged byte for byte.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: write the latest reference as its own file, with the site's front matter

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: leave indexing to the site

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: render the reference with griffe2md

Replaces the 539-line renderer with griffe2md, a dev dependency.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: write signatures with griffe and mark async methods

griffe2md 1.5.1's signature template gives an unannotated parameter the
previous parameter's annotation, so Client(...) showed `debug: str = False`.
It also drops `async`. Swap its format_signature filter for griffe's own
Function.signature(), prefixed with `async` for coroutines.

Also document OptionalSetArgs and CodeEmailArgs in Types, since set,
set_once and Emails.send reference them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: map capabilities in docs/capabilities.json instead of docstrings

The posthog-capability lines showed in IDE hover help. The docstrings
read as they do on main again, Category sections included, and the
generator drops those sections from the reference.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: list v1's context option methods in SDK utils

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: check the reference generator's signatures

Covers the two output bugs review reproduced: unannotated parameters getting the
previous parameter's annotation, and coroutines missing async. Also checks the
keyword-only marker. griffe and griffe2md join the test extra so CI runs them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: leave private parameters out of reference signatures

Client(...) listed _use_ai_lane and _enable_multimodal_capture.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: keep whole summaries and Returns, and call constructors by class name

- Summary tables keep a docstring's first paragraph, not its first line.
- A Returns section is one return value, even when its description wraps.
- A constructor's signature reads `Client(...)`, not `__init__(...)`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: fix three docstring examples

- The context example tags with `tag`, since `tag_context` doesn't exist.
- The `capture_exception` example passes `distinct_id` by keyword, since it's keyword-only.
- Two reST `Example::` blocks become Markdown, which the reference renders.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: add the steps to a first event to the Python getting-started intro

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 bin/docs_scripts/generate_markdown.py   | 266 ++++++++++++++++++++++++
 docs/capabilities.json                  |  82 ++++++++
 docs/getting-started.md                 |  39 ++++
 posthog/__init__.py                     |   4 +-
 posthog/capture_compression.py          |   6 +
 posthog/client.py                       |   7 +-
 posthog/emails.py                       |  27 ++-
 posthog/feature_flag_evaluations.py     |  12 +-
 posthog/feature_flags.py                |   6 +
 posthog/test/test_reference_markdown.py |  67 ++++++
 posthog/types.py                        |  14 +-
 pyproject.toml                          |   4 +
 uv.lock                                 |  61 ++++++
 13 files changed, 581 insertions(+), 14 deletions(-)
 create mode 100644 bin/docs_scripts/generate_markdown.py
 create mode 100644 docs/capabilities.json
 create mode 100644 docs/getting-started.md
 create mode 100644 posthog/test/test_reference_markdown.py

diff --git a/bin/docs_scripts/generate_markdown.py b/bin/docs_scripts/generate_markdown.py
new file mode 100644
index 000000000..8ade17f58
--- /dev/null
+++ b/bin/docs_scripts/generate_markdown.py
@@ -0,0 +1,266 @@
+"""Generate the SDK reference Markdown from source with griffe2md, which never imports the SDK.
+
+docs/capabilities.json maps each entry's label to a PostHog/sdk-specs capability, shown in
+the sdk-specs README's order. Its `utils` lists the Client members that go to SDK utils, and
+its `next` maps labels that only the next major has.
+
+    python bin/docs_scripts/generate_markdown.py --sdk-specs DIR [--major 8]
+"""
+
+import argparse
+import copy
+import json
+import logging
+import re
+from pathlib import Path
+
+import griffe
+import griffe2md
+
+ROOT = Path(__file__).resolve().parents[2]
+TYPES = """args.OptionalCaptureArgs feature_flag_evaluations.FeatureFlagEvaluations types.FeatureFlagResult
+types.FeatureFlag types.FlagsAndPayloads types.UnresolvedFlagReason feature_flags.InconclusiveMatchError
+feature_flags.RequiresServerEvaluation capture_send.CaptureError tracing.span.Span emails.Emails
+emails.EmailError emails.SendEmailResult args.OptionalSetArgs emails.CodeEmailArgs""".split()
+UTILS = """integrations.django.PosthogContextMiddleware integrations.flask.PosthogFlaskIntegration
+integrations.asgi.PosthogASGIMiddleware integrations.celery.PosthogCeleryIntegration
+request.set_socket_options request.enable_keep_alive request.disable_connection_reuse""".split()
+FIRST = ["setup", "capture", "identify"]
+ROLE = re.compile(
+    r":(?:py:)?(?:meth|func|class|attr|obj|data|exc|mod|const):`~?([^`]+)`"
+)
+CONFIG = {
+    **griffe2md.default_config,
+    "docstring_section_style": "table",
+    "show_root_full_path": False,
+    "show_signature_annotations": True,
+    "separate_signature": True,
+    "heading_level": 3,
+}
+
+
+def clean(obj) -> None:
+    """Strips Sphinx roles, and the Category section the JSON docs read, from the docstrings."""
+    for o in [obj, *(m for m in obj.members.values() if not m.is_alias)]:
+        if o.docstring:
+            text = ROLE.sub(r"`\1`", o.docstring.value)
+            head, _, tail = text.partition("\nCategory:\n")
+            text = head.rstrip() + "".join(f"\n{t}" for t in tail.split("\n")[1:])
+            o.docstring.value = re.sub(r"(?<!`)``([^`]+)``(?!`)", r"`\1`", text)
+
+
+def signature(name, function, *_, **__) -> str:
+    """griffe2md's signature template gives an unannotated parameter the previous one's
+    annotation and drops `async`, so griffe writes the signature instead. Private
+    parameters, which start with `_`, are left out."""
+    prefix = "async " if "async" in function.labels else ""
+    public = copy.copy(function)
+    public.parameters = griffe.Parameters(
+        *(p for p in function.parameters if not p.name.startswith("_"))
+    )
+    # A constructor is called by its class's name.
+    name = function.parent.name if function.name == "__init__" else str(name).strip()
+    return prefix + public.signature(name=name)
+
+
+def whole_summaries(build):
+    """griffe2md's summary tables keep the first line of each docstring, which can stop
+    mid-sentence, so they keep the whole first paragraph instead."""
+
+    def section(objects, **kwargs):
+        out = build(objects, **kwargs)
+        docstrings = {o.name: o.docstring for o in objects}
+        for item in out.value:
+            if docstring := docstrings[item.name]:
+                item.description = " ".join(docstring.value.split("\n\n", 1)[0].split())
+        return out
+
+    return section
+
+
+ENV = griffe2md.prepare_env()
+ENV.filters["format_signature"] = signature
+for kind in ("functions", "classes", "attributes"):
+    ENV.filters[f"as_{kind}_section"] = whole_summaries(
+        ENV.filters[f"as_{kind}_section"]
+    )
+
+
+def entry(obj, name: str) -> str:
+    template = ENV.get_template(f"{obj.kind.value}.md.jinja")
+    md = template.render(**griffe2md.prepare_context(obj, CONFIG))
+    # Annotation links point at anchors this page doesn't have.
+    md = re.sub(r"\[([^\]]+)\]\(#[\w.]+\)", r"\1", md)
+    # The site reads Markdown as MDX 1: HTML must be JSX, and braces in <code> are expressions.
+    md = re.sub(r"<code>(.*?)</code>", r"`\1`", md.replace("<br>", "<br />"))
+    # A parameter documented only in the docstring, like a **kwargs key, isn't required.
+    md = re.sub(r"^(`\w+` \|  \| .*) \| \*required\*$", r"\1 | ", md, flags=re.M)
+    return re.sub(r"^### .*$", f"### `{name}`", md.strip(), count=1, flags=re.M)
+
+
+def methods(cls) -> list:
+    """Public methods and properties, and `__init__`."""
+    return [
+        m
+        for n, m in cls.members.items()
+        if not m.is_alias
+        and (m.is_function or "property" in m.labels)
+        and (not n.startswith("_") or n == "__init__")
+    ]
+
+
+def label(prefix: str, m) -> str:
+    return f"{prefix}(...)" if m.name == "__init__" else f"{prefix}.{m.name}"
+
+
+def capabilities(checkout: str) -> dict[str, str]:
+    """Each sdk-specs capability's slug and title in sentence case, in the README's order."""
+    readme = (Path(checkout) / "README.md").read_text()
+    rows = re.findall(
+        r"^\| ([^|]+?) \| \[`openspec/specs/([a-z0-9-]+)/spec\.md`\]", readme, re.M
+    )
+    acronyms = {"id": "ID", "ai": "AI", "http": "HTTP", "mcp": "MCP"}
+    titles = {
+        s: " ".join(acronyms.get(w.lower(), w.lower()) for w in n.split())
+        for n, s in rows
+    }
+    # Setup, capture and identify come first; the rest follow the README.
+    order = [*FIRST, *(s for s in titles if s not in FIRST)]
+    return {s: titles[s][0].upper() + titles[s][1:] for s in order if s in titles}
+
+
+def has(pkg, path: str) -> bool:
+    try:
+        pkg[path]
+        return True
+    except KeyError:
+        return False
+
+
+def reference(pkg, caps: dict[str, str], current: bool) -> list[str]:
+    """`current` is false for a next major, which can remove what the map names."""
+    order = {slug: i for i, slug in enumerate(caps)}
+    utils, types = ([pkg[p] for p in paths if has(pkg, p)] for paths in (UTILS, TYPES))
+    module = [
+        m
+        for n, m in pkg.members.items()
+        if not m.is_alias and m.is_function and not n.startswith("_")
+    ]
+    sync, asyncs = (
+        methods(pkg["client.Client"]),
+        methods(pkg["async_client.AsyncClient"]),
+    )
+    found = {label("Client", m) for m in sync} | {
+        label("AsyncClient", m) for m in asyncs
+    }
+    found |= {f"posthog.{m.name}" for m in module}
+    for obj in [*sync, *asyncs, *module, *utils, *types]:
+        clean(obj)
+    data = json.loads((ROOT / "docs/capabilities.json").read_text())
+    utils_names, later = set(data.pop("utils")), data.pop("next", {})
+    mapped = {**later, **data}
+    for name, slug in mapped.items():
+        if current and name not in found and name not in later:
+            raise SystemExit(f"docs/capabilities.json: no symbol for {name}")
+        if slug not in caps:
+            raise SystemExit(
+                f"docs/capabilities.json: {name}: {slug} isn't in sdk-specs"
+            )
+    for name in sorted(found - mapped.keys() - utils_names):
+        if name.startswith("Client"):
+            raise SystemExit(f"docs/capabilities.json: map {name} or add it to utils")
+    client = [(mapped.get(label("Client", m)), m) for m in sync]
+    asyncs = sorted(
+        ((mapped.get(label("AsyncClient", m)), m) for m in asyncs),
+        key=lambda e: order.get(e[0] or "", len(order)),
+    )
+    out = []
+    for slug, title in caps.items():
+        if tagged := [m for t, m in client if t == slug]:
+            out += [f"## {title}", *(entry(m, label("Client", m)) for m in tagged)]
+    out += ["## SDK utils", *(entry(m, label("Client", m)) for t, m in client if not t)]
+    out += [entry(o, f"posthog.{o.path.removeprefix('posthog.')}") for o in utils]
+    out += ["## AsyncClient", "Needs the `async` extra, `posthog[async]`."]
+    out += [entry(m, label("AsyncClient", m)) for _, m in asyncs]
+    out += ["## Module functions", *(entry(m, f"posthog.{m.name}") for m in module)]
+    return out + ["## Types", *(entry(o, o.name) for o in types)]
+
+
+def front_matter(title: str, sections: list[str]) -> str:
+    """The docs site's front matter. Its ToC lists the page's H2 sections only."""
+    toc = []
+    for heading in [s[3:] for s in sections if s.startswith("## ")]:
+        anchor = re.sub(r"[^\w\- ]", "", heading.lower()).replace(" ", "-")
+        toc.append(f'  - value: "{heading}"\n    url: {anchor}\n    depth: 0')
+    head = [f'title: "{title}"', "sidebar: Docs", "showTitle: true"]
+    head += [
+        "contentMaxWidthClass: max-w-full",
+        "platformLogo: python",
+        "tableOfContents:",
+        *toc,
+    ]
+    return "\n".join(["---", *head, "---"])
+
+
+def nest(markdown: str) -> str:
+    """Moves each heading down one level and drops the H1. Code stays as written."""
+    out, in_fence = [], False
+    for line in markdown.strip().split("\n"):
+        in_fence ^= bool(re.match(r"\s*```", line))
+        if in_fence or not re.match(r"#{1,5} ", line):
+            out.append(line)
+        elif not line.startswith("# "):
+            out.append("#" + line)
+    return "\n".join(out)
+
+
+def write(name: str, sections: list[str]) -> None:
+    (ROOT / "references" / name).write_text("\n\n".join(sections) + "\n")
+    print(f"wrote references/{name}")
+
+
+def main() -> None:
+    args = argparse.ArgumentParser(description="Generate the SDK reference Markdown.")
+    args.add_argument("--sdk-specs", required=True, help="PostHog/sdk-specs checkout")
+    args.add_argument(
+        "--major", type=int, help="target major, defaults to the declared one"
+    )
+    opts = args.parse_args()
+    logging.getLogger("griffe").setLevel(logging.ERROR)
+    pkg = griffe.load(
+        "posthog",
+        search_paths=[str(ROOT)],
+        docstring_parser="google",
+        # A Returns section is one return value, even when its description wraps.
+        docstring_options={"returns_multiple_items": False},
+        resolve_aliases=False,
+    )
+    declared = int(
+        (ROOT / "posthog/version.py").read_text().split('"')[1].split(".")[0]
+    )
+    major = opts.major or declared
+    started = nest((ROOT / "docs/getting-started.md").read_text())
+    body = [
+        "## Getting started",
+        started,
+        *reference(pkg, capabilities(opts.sdk_specs), declared >= major),
+    ]
+    title = f"PostHog Python SDK {major}.x" + (
+        "" if declared >= major else " (experimental)"
+    )
+    write(f"posthog-python-{major}.md", [front_matter(title, body), *body])
+    if declared >= major:
+        write(
+            "posthog-python-reference.md",
+            [front_matter("PostHog Python SDK", body), *body],
+        )
+    if guides := sorted((ROOT / "docs").glob("migration-*.md"), reverse=True):
+        head = "---\ntitle: PostHog Python SDK migration guides\nsidebar: Docs\nshowTitle: true\n---"
+        write(
+            "posthog-python-migration.md",
+            [head, *(g.read_text().strip() for g in guides)],
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/capabilities.json b/docs/capabilities.json
new file mode 100644
index 000000000..7bf0d6031
--- /dev/null
+++ b/docs/capabilities.json
@@ -0,0 +1,82 @@
+{
+  "AsyncClient(...)": "setup",
+  "AsyncClient.alias": "alias",
+  "AsyncClient.capture": "capture",
+  "AsyncClient.capture_exception": "capture-exception",
+  "AsyncClient.capture_immediate": "capture",
+  "AsyncClient.emails": "emails",
+  "AsyncClient.evaluate_flags": "evaluate-flags",
+  "AsyncClient.flush": "flush",
+  "AsyncClient.group_identify": "group-identify",
+  "AsyncClient.join": "shutdown",
+  "AsyncClient.set": "identify",
+  "AsyncClient.set_once": "identify",
+  "AsyncClient.shutdown": "shutdown",
+  "Client(...)": "setup",
+  "Client.alias": "alias",
+  "Client.capture": "capture",
+  "Client.capture_ai": "capture-ai",
+  "Client.capture_exception": "capture-exception",
+  "Client.emails": "emails",
+  "Client.evaluate_flags": "evaluate-flags",
+  "Client.feature_enabled": "is-feature-enabled",
+  "Client.feature_flag_definitions": "flag-definition-loader",
+  "Client.flush": "flush",
+  "Client.get_active_span": "traces",
+  "Client.get_all_flags": "get-feature-flags",
+  "Client.get_all_flags_and_payloads": "get-feature-flags-and-payloads",
+  "Client.get_feature_flag": "get-feature-flag",
+  "Client.get_feature_flag_payload": "get-feature-flag-payload",
+  "Client.get_feature_flag_result": "get-feature-flag-result",
+  "Client.get_feature_flags_and_payloads": "get-feature-flags-and-payloads",
+  "Client.get_feature_variants": "get-feature-flags",
+  "Client.group_identify": "group-identify",
+  "Client.join": "shutdown",
+  "Client.load_feature_flags": "flag-definition-loader",
+  "Client.set": "identify",
+  "Client.set_once": "identify",
+  "Client.shutdown": "shutdown",
+  "Client.start_span": "traces",
+  "posthog.alias": "alias",
+  "posthog.capture": "capture",
+  "posthog.capture_ai": "capture-ai",
+  "posthog.capture_exception": "capture-exception",
+  "posthog.evaluate_flags": "evaluate-flags",
+  "posthog.feature_enabled": "is-feature-enabled",
+  "posthog.feature_flag_definitions": "flag-definition-loader",
+  "posthog.flush": "flush",
+  "posthog.get_active_span": "traces",
+  "posthog.get_all_flags": "get-feature-flags",
+  "posthog.get_all_flags_and_payloads": "get-feature-flags-and-payloads",
+  "posthog.get_feature_flag": "get-feature-flag",
+  "posthog.get_feature_flag_payload": "get-feature-flag-payload",
+  "posthog.get_feature_flag_result": "get-feature-flag-result",
+  "posthog.group_identify": "group-identify",
+  "posthog.join": "shutdown",
+  "posthog.load_feature_flags": "flag-definition-loader",
+  "posthog.set": "identify",
+  "posthog.set_once": "identify",
+  "posthog.setup": "setup",
+  "posthog.shutdown": "shutdown",
+  "posthog.start_span": "traces",
+  "utils": [
+    "Client.consumers",
+    "Client.feature_flags",
+    "Client.get_context_options",
+    "Client.get_feature_flag_evaluation_runtime",
+    "Client.get_feature_flag_keys_by_evaluation_runtime",
+    "Client.get_feature_payloads",
+    "Client.get_flags_decision",
+    "Client.get_remote_config_payload",
+    "Client.get_tags",
+    "Client.identify_context",
+    "Client.metrics",
+    "Client.new_context",
+    "Client.queue",
+    "Client.scoped",
+    "Client.set_context_device_id",
+    "Client.set_context_option",
+    "Client.set_context_session",
+    "Client.tag"
+  ]
+}
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 000000000..27d91f176
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,39 @@
+# Getting started
+
+The Python SDK captures events, evaluates feature flags and reports errors from Python 3.10 or later.
+
+To send your first event, install the package, create a client, capture an event, and shut the client down, as the steps below show.
+
+## Install
+
+```bash
+pip install posthog
+```
+
+## Initialize
+
+Create one client for your app with your project token and host. Your project token and host are in your [project settings](https://app.posthog.com/project/settings). Keep the token in an environment variable rather than in code.
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("<ph_project_token>", host="<ph_client_api_host>")
+```
+
+## Capture an event
+
+```python
+posthog.capture("user_signed_up", distinct_id="user_123", properties={"plan": "free"})
+```
+
+`capture` queues the event and returns right away. A background thread sends it.
+
+## Shut down
+
+Call `shutdown()` before your process exits, so queued events are sent.
+
+```python
+posthog.shutdown()
+```
+
+In an asyncio app, use `AsyncPosthog` as an async context manager instead. See [AsyncClient](#asyncclient).
diff --git a/posthog/__init__.py b/posthog/__init__.py
index d9f6d174f..705c4e5b7 100644
--- a/posthog/__init__.py
+++ b/posthog/__init__.py
@@ -493,7 +493,7 @@ def capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]:
     Examples:
         ```python
         # Context and capture usage
-        from posthog import new_context, identify_context, tag_context, capture
+        from posthog import new_context, identify_context, tag, capture
         # Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)
         with new_context():
             # Associate this context with some user, by distinct_id
@@ -514,7 +514,7 @@ def capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]:
             capture('purchase', groups={'company': 'id:5'})
 
             # Adding a tag to the current context will cause it to appear on all subsequent events
-            tag_context('some-tag', 'some-value')
+            tag('some-tag', 'some-value')
 
             capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict
         ```
diff --git a/posthog/capture_compression.py b/posthog/capture_compression.py
index 659c12fab..7b6760d06 100644
--- a/posthog/capture_compression.py
+++ b/posthog/capture_compression.py
@@ -30,6 +30,12 @@ class CaptureCompression(str, Enum):
     server decodes (``br`` is accepted by the server too but is intentionally
     left out for now). Inheriting from ``str`` keeps the members comparable to
     and serializable as their token values.
+
+    Values:
+        NONE: Sends the body uncompressed.
+        GZIP: gzip, from the standard library.
+        DEFLATE: zlib (RFC 1950), from the standard library.
+        ZSTD: Faster and smaller, but needs ``pip install posthog[zstd]``.
     """
 
     NONE = "none"
diff --git a/posthog/client.py b/posthog/client.py
index 66c161866..2eb144a56 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -770,9 +770,8 @@ def __init__(
             poll_interval: Seconds between local feature flag definition refreshes.
             secret_key: A Personal API Key or Project Secret API Key, used to
                 authenticate local feature flag evaluation, remote config
-                payloads, and decrypted flag payloads. Example::
-
-                    posthog.Client(project_api_key, secret_key="phx_...")
+                payloads, and decrypted flag payloads. For example,
+                `posthog.Client(project_api_key, secret_key="phx_...")`.
 
             personal_api_key: Deprecated alias for ``secret_key``. Still honored
                 for backwards compatibility; prefer ``secret_key``, which also
@@ -2273,7 +2272,7 @@ def capture_exception(
                 # Some code that might fail
                 pass
             except Exception as e:
-                posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)
+                posthog.capture_exception(e, distinct_id='user_distinct_id', properties=additional_properties)
             ```
 
         Category:
diff --git a/posthog/emails.py b/posthog/emails.py
index c53528c7c..42e70b971 100644
--- a/posthog/emails.py
+++ b/posthog/emails.py
@@ -155,6 +155,17 @@ class EmailError(Exception):
     Branch on ``code``, PostHog's stable error code, or on ``name``, a coarse
     category of the failure. The message never contains the secret key or the
     request body.
+
+    Attributes:
+        name: A coarse category of the failure.
+        code: PostHog's stable error code.
+        message: What went wrong. It never contains the secret key or the request body.
+        status_code: The HTTP status of the response, or ``None`` when none arrived.
+        why: PostHog's explanation of the failure, when it gave one.
+        fix: What to change to fix it, when PostHog said.
+        docs_url: A docs page about the error, when PostHog gave one.
+        field: The request field the error is about, when there is one.
+        retry_after: Seconds to wait before retrying, when PostHog said.
     """
 
     def __init__(
@@ -191,7 +202,14 @@ class EmailWarning:
 
 @dataclass(frozen=True)
 class SendEmailResult:
-    """The queued email. ``id`` is its message ID."""
+    """The queued email. ``id`` is its message ID.
+
+    Attributes:
+        id: The email's message ID.
+        replayed: ``True`` when the response says PostHog replayed an earlier send for
+            the same ``idempotency_key`` instead of sending again.
+        warnings: Warnings PostHog returned about the request.
+    """
 
     id: str
     replayed: bool = False
@@ -294,6 +312,13 @@ class EmailStatus:
     ``reason`` says why a failed email was not sent, such as
     ``provider_error`` or ``recipient_suppressed``, or gives the bounce type of
     a bounced email: ``hard``, ``soft`` or ``unknown``. It is ``None`` otherwise.
+
+    Attributes:
+        id: The email's message ID.
+        status: Where the email is now, one of the values above.
+        created_at: When PostHog queued the email.
+        status_at: When the email reached its current status.
+        reason: Why a failed email was not sent, or a bounced email's bounce type.
     """
 
     id: str
diff --git a/posthog/feature_flag_evaluations.py b/posthog/feature_flag_evaluations.py
index 28e5bf31e..1a9a170d8 100644
--- a/posthog/feature_flag_evaluations.py
+++ b/posthog/feature_flag_evaluations.py
@@ -115,12 +115,12 @@ class FeatureFlagEvaluations:
     ``flags`` option so the captured event carries the exact flag values the code
     branched on.
 
-    Example::
-
-        flags = posthog.evaluate_flags(distinct_id, person_properties={"plan": "enterprise"})
-        if flags.is_enabled("new-dashboard"):
-            render_new_dashboard()
-        posthog.capture("page_viewed", distinct_id=distinct_id, flags=flags)
+    ```python
+    flags = posthog.evaluate_flags(distinct_id, person_properties={"plan": "enterprise"})
+    if flags.is_enabled("new-dashboard"):
+        render_new_dashboard()
+    posthog.capture("page_viewed", distinct_id=distinct_id, flags=flags)
+    ```
 
     To narrow the set of flags that get attached to a captured event, use the in-memory
     helpers :meth:`only` and :meth:`only_accessed`. To narrow the set of flags requested
diff --git a/posthog/feature_flags.py b/posthog/feature_flags.py
index bf10cf946..6634ae367 100644
--- a/posthog/feature_flags.py
+++ b/posthog/feature_flags.py
@@ -99,6 +99,9 @@ class InconclusiveMatchError(Exception):
     """
     Raised when local evaluation can't determine a flag's value. ``reason`` says
     why, as reported by ``FeatureFlagEvaluations.unresolved_flags``.
+
+    Attributes:
+        reason: Why local evaluation couldn't resolve the flag.
     """
 
     reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
@@ -116,6 +119,9 @@ class RequiresServerEvaluation(Exception):
 
     This error should propagate immediately to trigger API fallback, unlike
     InconclusiveMatchError which allows trying other conditions.
+
+    Attributes:
+        reason: Why the flag needs server-side evaluation.
     """
 
     reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
diff --git a/posthog/test/test_reference_markdown.py b/posthog/test/test_reference_markdown.py
new file mode 100644
index 000000000..bba347504
--- /dev/null
+++ b/posthog/test/test_reference_markdown.py
@@ -0,0 +1,67 @@
+"""Checks the Markdown reference generator's signatures, which griffe2md's own template got wrong."""
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+griffe = pytest.importorskip("griffe")
+pytest.importorskip("griffe2md")
+
+ROOT = Path(__file__).resolve().parents[2]
+_spec = importlib.util.spec_from_file_location(
+    "generate_markdown", ROOT / "bin/docs_scripts/generate_markdown.py"
+)
+generator = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(generator)
+
+
+@pytest.fixture(scope="module")
+def pkg():
+    return griffe.load(
+        "posthog",
+        search_paths=[str(ROOT)],
+        docstring_parser="google",
+        docstring_options={"returns_multiple_items": False},
+        resolve_aliases=False,
+    )
+
+
+def declaration(pkg, path: str) -> str:
+    """The first line of the entry's code block."""
+    md = generator.entry(pkg[path], path)
+    return md.split("```python\n", 1)[1].split("\n", 1)[0]
+
+
+def test_unannotated_parameters_get_no_annotation(pkg):
+    line = declaration(pkg, "client.Client.__init__")
+    assert "debug=False" in line
+    assert "debug: str" not in line
+    assert "_use_ai_lane" not in line, "private parameters stay out of the signature"
+
+
+def test_coroutines_are_marked_async(pkg):
+    assert declaration(pkg, "async_client.AsyncClient.flush").startswith("async ")
+    assert not declaration(pkg, "async_client.AsyncClient.capture").startswith("async ")
+
+
+def test_keyword_only_marker_is_kept(pkg):
+    assert ", *, groups" in declaration(pkg, "client.Client.evaluate_flags")
+
+
+def test_constructor_is_called_by_its_class_name(pkg):
+    assert declaration(pkg, "client.Client.__init__").startswith("Client(")
+
+
+def test_a_wrapped_returns_description_is_one_row(pkg):
+    md = generator.entry(
+        pkg["client.Client.get_feature_flag_payload"], "Client.get_feature_flag_payload"
+    )
+    assert md.count("`Optional[object]` |") == 1
+
+
+def test_summaries_keep_the_whole_first_paragraph(pkg):
+    cls = pkg["feature_flag_evaluations.FeatureFlagEvaluations"]
+    generator.clean(cls)
+    md = generator.entry(cls, "FeatureFlagEvaluations")
+    assert "on the first access per (distinct_id, flag, value) tuple" in md
diff --git a/posthog/types.py b/posthog/types.py
index 370044f84..229b25a16 100644
--- a/posthog/types.py
+++ b/posthog/types.py
@@ -84,6 +84,11 @@ class FeatureFlagEvaluationRuntime(str, Enum):
     ``ALL`` means the flag suits both client-side and server-side evaluation, so
     it matches either runtime. Inheriting from ``str`` keeps the members directly
     comparable to their ``"all"`` / ``"client"`` / ``"server"`` values.
+
+    Values:
+        ALL: The flag suits both client-side and server-side evaluation.
+        CLIENT: The flag is meant for client-side evaluation.
+        SERVER: The flag is meant for server-side evaluation.
     """
 
     ALL = "all"
@@ -278,6 +283,7 @@ def __post_init__(self) -> None:
         )
 
     def get_value(self) -> FlagValue:
+        """Return the variant for a multivariate flag, otherwise whether the flag is enabled."""
         return self.variant or self.enabled
 
     @classmethod
@@ -294,6 +300,7 @@ def from_json(cls, resp: Any) -> "FeatureFlag":
     def from_value_and_payload(
         cls, key: str, value: FlagValue, payload: Any
     ) -> "FeatureFlag":
+        """Build a flag from its value and payload. A string value is a variant, so the flag is enabled."""
         enabled, variant = (True, value) if isinstance(value, str) else (value, None)
         return cls(
             key=key,
@@ -548,7 +555,12 @@ class FlagsResponse(TypedDict, total=False):
 
 
 class FlagsAndPayloads(TypedDict, total=True):
-    """Feature flag values and payloads keyed by feature flag key."""
+    """Feature flag values and payloads keyed by feature flag key.
+
+    Attributes:
+        featureFlags: Each flag's value, keyed by flag key.
+        featureFlagPayloads: Each flag's payload, keyed by flag key.
+    """
 
     featureFlags: Optional[dict[str, FlagValue]]
     featureFlagPayloads: Optional[dict[str, Any]]
diff --git a/pyproject.toml b/pyproject.toml
index 590cd3a91..aaefb1b5f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -64,6 +64,7 @@ metrics = [
 dev = [
     "django-stubs",
     "griffe",
+    "griffe2md",
     "lxml",
     "mypy",
     "mypy-baseline",
@@ -123,6 +124,9 @@ test = [
     "opentelemetry-instrumentation-django>=0.60b0",
     "pytest-bdd>=8.1.0",
     "zstandard>=0.23.0",
+    # posthog/test/test_reference_markdown.py checks the reference generator's output.
+    "griffe",
+    "griffe2md",
     # gevent 25.4.1+ replaces queue.Queue, exercising the compatibility path.
     "gevent>=25.4.1; implementation_name == 'cpython'",
 ]
diff --git a/uv.lock b/uv.lock
index 91ca4f896..c92385a2d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1393,6 +1393,46 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/94/c0/2bb018eecf9a83c68db9cd9fffd9dab25f102ad30ed869451046e46d1187/griffe-2.0.2-py3-none-any.whl", hash = "sha256:2b31816460aee1996af26050a1fc6927a2e5936486856707f55508e4c9b5960b", size = 5141, upload-time = "2026-03-27T11:34:47.721Z" },
 ]
 
+[[package]]
+name = "griffe2md"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "griffelib" },
+    { name = "jinja2" },
+    { name = "mdformat" },
+    { name = "tomli" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/a8/18adadd26454832fb0beaea07e5f05b92f8830a112ec860d3c403914d651/griffe2md-1.5.0.tar.gz", hash = "sha256:58e184dffcd506ca97f54516dc07dd41f98ddc76eb17ba30518cf3dda18f6a51", size = 47309, upload-time = "2026-03-12T16:22:01.392Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/50/75d7902f3a82e77710123418e905302309e116c4d12050f04cf6f4ed9d4e/griffe2md-1.5.0-py3-none-any.whl", hash = "sha256:1becaff032cb02ffedd46057a83c218400bb586579c37010ec8504377108591d", size = 32367, upload-time = "2026-03-12T16:22:00.237Z" },
+]
+
+[[package]]
+name = "griffe2md"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*' and sys_platform == 'win32'",
+    "python_full_version == '3.13.*' and sys_platform != 'win32'",
+    "python_full_version == '3.12.*'",
+    "python_full_version == '3.11.*'",
+]
+dependencies = [
+    { name = "griffelib" },
+    { name = "jinja2" },
+    { name = "mdformat" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/28/588e886370cb55d351895c86e5b9574293769a902b7f722d341f08d357d2/griffe2md-1.5.1.tar.gz", hash = "sha256:6ccf7ed1db2955c70b88eabf404f4f6a2c632d50790157fc3d3b7d269017dffd", size = 50114, upload-time = "2026-10-06T09:10:33.521Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/d3/c45c4e97e10b8ec466d472a35f10a651080ddec636dc805599a305f5d4ac/griffe2md-1.5.1-py3-none-any.whl", hash = "sha256:74ef2ed31926b241186f7c4c5f3f30725e4579468717d4c4f7f1565b41f40f8a", size = 37338, upload-time = "2026-10-06T09:10:32.153Z" },
+]
+
 [[package]]
 name = "griffecli"
 version = "2.0.2"
@@ -2271,6 +2311,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
 ]
 
+[[package]]
+name = "mdformat"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3f/05/32b5e14b192b0a8a309f32232c580aefedd9d06017cb8fe8fce34bec654c/mdformat-1.0.0.tar.gz", hash = "sha256:4954045fcae797c29f86d4ad879e43bb151fa55dbaf74ac6eaeacf1d45bb3928", size = 56953, upload-time = "2025-10-16T12:05:03.695Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/9a/8fe71b95985ca7a4001effbcc58e5a07a1f2a2884203f74dcf48a3b08315/mdformat-1.0.0-py3-none-any.whl", hash = "sha256:bca015d65a1d063a02e885a91daee303057bc7829c2cd37b2075a50dbb65944b", size = 53288, upload-time = "2025-10-16T12:05:02.607Z" },
+]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -3243,6 +3296,8 @@ async = [
 dev = [
     { name = "django-stubs" },
     { name = "griffe" },
+    { name = "griffe2md", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "griffe2md", version = "1.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "lxml" },
     { name = "mypy" },
     { name = "mypy-baseline" },
@@ -3284,6 +3339,9 @@ test = [
     { name = "freezegun" },
     { name = "gevent", marker = "implementation_name == 'cpython'" },
     { name = "google-genai" },
+    { name = "griffe" },
+    { name = "griffe2md", version = "1.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "griffe2md", version = "1.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "jsonschema" },
     { name = "langchain" },
     { name = "langchain-anthropic" },
@@ -3344,6 +3402,9 @@ requires-dist = [
     { name = "gevent", marker = "implementation_name == 'cpython' and extra == 'test'", specifier = ">=25.4.1" },
     { name = "google-genai", marker = "extra == 'test'" },
     { name = "griffe", marker = "extra == 'dev'" },
+    { name = "griffe", marker = "extra == 'test'" },
+    { name = "griffe2md", marker = "extra == 'dev'" },
+    { name = "griffe2md", marker = "extra == 'test'" },
     { name = "httpx", marker = "extra == 'async'", specifier = ">=0.27.0,<1.0" },
     { name = "jsonschema", marker = "extra == 'test'", specifier = ">=4.0" },
     { name = "langchain", marker = "extra == 'langchain'", specifier = ">=1.3.9" },

From 32e8f41dd9c1ac98988516899027162bfb18c29e Mon Sep 17 00:00:00 2001
From: "Vincent (Wen Yu) Ge" <29069505+gewenyu99@users.noreply.github.com>
Date: Tue, 10 Nov 2026 15:11:37 -0500
Subject: [PATCH 234/245] docs: generate the 7.x Markdown reference (#1183)

* docs: generate the 7.x Markdown reference

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x reference and its latest file

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x pages

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x pages with griffe2md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x reference from current main

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7 and reference pages

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7 and reference pages from the capability map

The Category boxes are gone; nothing else changed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x reference without private parameters

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 7.x reference with whole summaries and Returns

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the Python 7.x reference with the getting-started intro

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 references/posthog-python-7.md         | 4100 ++++++++++++++++++++++++
 references/posthog-python-reference.md | 4100 ++++++++++++++++++++++++
 2 files changed, 8200 insertions(+)
 create mode 100644 references/posthog-python-7.md
 create mode 100644 references/posthog-python-reference.md

diff --git a/references/posthog-python-7.md b/references/posthog-python-7.md
new file mode 100644
index 000000000..ab200d47e
--- /dev/null
+++ b/references/posthog-python-7.md
@@ -0,0 +1,4100 @@
+---
+title: "PostHog Python SDK 7.x"
+sidebar: Docs
+showTitle: true
+contentMaxWidthClass: max-w-full
+platformLogo: python
+tableOfContents:
+  - value: "Getting started"
+    url: getting-started
+    depth: 0
+  - value: "Setup"
+    url: setup
+    depth: 0
+  - value: "Capture"
+    url: capture
+    depth: 0
+  - value: "Identify"
+    url: identify
+    depth: 0
+  - value: "Traces"
+    url: traces
+    depth: 0
+  - value: "Alias"
+    url: alias
+    depth: 0
+  - value: "Capture AI"
+    url: capture-ai
+    depth: 0
+  - value: "Capture exception"
+    url: capture-exception
+    depth: 0
+  - value: "Emails"
+    url: emails
+    depth: 0
+  - value: "Flush"
+    url: flush
+    depth: 0
+  - value: "Get feature flag"
+    url: get-feature-flag
+    depth: 0
+  - value: "Get feature flag payload"
+    url: get-feature-flag-payload
+    depth: 0
+  - value: "Get feature flag result"
+    url: get-feature-flag-result
+    depth: 0
+  - value: "Get feature flags"
+    url: get-feature-flags
+    depth: 0
+  - value: "Get feature flags and payloads"
+    url: get-feature-flags-and-payloads
+    depth: 0
+  - value: "Evaluate flags"
+    url: evaluate-flags
+    depth: 0
+  - value: "Group identify"
+    url: group-identify
+    depth: 0
+  - value: "Is feature enabled"
+    url: is-feature-enabled
+    depth: 0
+  - value: "Shutdown"
+    url: shutdown
+    depth: 0
+  - value: "Flag definition loader"
+    url: flag-definition-loader
+    depth: 0
+  - value: "SDK utils"
+    url: sdk-utils
+    depth: 0
+  - value: "AsyncClient"
+    url: asyncclient
+    depth: 0
+  - value: "Module functions"
+    url: module-functions
+    depth: 0
+  - value: "Types"
+    url: types
+    depth: 0
+---
+
+## Getting started
+
+
+The Python SDK captures events, evaluates feature flags and reports errors from Python 3.10 or later.
+
+To send your first event, install the package, create a client, capture an event, and shut the client down, as the steps below show.
+
+### Install
+
+```bash
+pip install posthog
+```
+
+### Initialize
+
+Create one client for your app with your project token and host. Your project token and host are in your [project settings](https://app.posthog.com/project/settings). Keep the token in an environment variable rather than in code.
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("<ph_project_token>", host="<ph_client_api_host>")
+```
+
+### Capture an event
+
+```python
+posthog.capture("user_signed_up", distinct_id="user_123", properties={"plan": "free"})
+```
+
+`capture` queues the event and returns right away. A background thread sends it.
+
+### Shut down
+
+Call `shutdown()` before your process exits, so queued events are sent.
+
+```python
+posthog.shutdown()
+```
+
+In an asyncio app, use `AsyncPosthog` as an async context manager instead. See [AsyncClient](#asyncclient).
+
+## Setup
+
+### `Client(...)`
+
+```python
+Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None)
+```
+
+Initialize a new PostHog client instance.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`project_api_key` | `str` | PostHog project API key/token. | *required*
+`host` |  | PostHog host. Defaults to the US ingestion endpoint when not set. App hosts such as `https://us.posthog.com` are mapped to the corresponding ingestion host. | `None`
+`debug` |  | Enable verbose SDK logging and re-raise errors from public API methods. | `False`
+`max_queue_size` |  | Maximum number of events buffered before upload. | `10000`
+`send` |  | If False, queueing succeeds but events are not sent. | `True`
+`on_error` |  | Optional callback invoked by background consumers when an upload fails. Keep it short and non-blocking. Calling lifecycle methods directly is safe and deferred, but do not start another thread or task that calls `flush()`, `join()`, or `shutdown()` and then wait for it from the callback. | `None`
+`flush_at` |  | Number of queued events that triggers a batch upload. | `100`
+`flush_interval` |  | Maximum seconds a background consumer waits before flushing a partial batch. | `5.0`
+`gzip` |  | Whether to gzip event upload payloads. | `False`
+`max_retries` |  | Number of upload retries. Values below 0 are treated as 0. | `3`
+`sync_mode` |  | If True, send each event synchronously instead of using background worker threads. This blocks the calling thread; in asyncio applications such as FastAPI, use `AsyncPosthog` instead. | `False`
+`timeout` | `float` | HTTP request timeout in seconds for event uploads. | `15`
+`thread` |  | Number of background consumer threads. | `1`
+`poll_interval` |  | Seconds between local feature flag definition refreshes. | `30`
+`secret_key` |  | A Personal API Key or Project Secret API Key, used to authenticate local feature flag evaluation, remote config payloads, and decrypted flag payloads. For example, `posthog.Client(project_api_key, secret_key="phx_...")`. | `None`
+`personal_api_key` |  | Deprecated alias for `secret_key`. Still honored for backwards compatibility; prefer `secret_key`, which also accepts a Project Secret API Key. | `None`
+`disabled` |  | If True, disable captures and API requests. Useful in tests. | `False`
+`disable_geoip` |  | Whether to disable server-side GeoIP enrichment. Defaults to True. | `True`
+`is_server` |  | Whether events are emitted from a server-side runtime. Defaults to True; set to False when using the SDK as a client/CLI so the device OS is attributed to the person normally. | `True`
+`historical_migration` |  | Mark events as historical migration imports. | `False`
+`feature_flags_request_timeout_seconds` | `float` | Timeout in seconds for feature flag and remote config requests. | `3`
+`feature_flags_request_max_retries` |  | Number of retries for feature flag requests after network, transport, or timeout failures. Defaults to 1. Set to 0 to disable retries. | `1`
+`app_host` | `Optional[str]` | Your PostHog app host, such as `https://posthog.example.com`. `emails` sends there. Needed only when `host` is not PostHog Cloud, for example a reverse proxy, which must not receive the secret key. | `None`
+`email_request_timeout_seconds` | `float` | Timeout in seconds for each email send request. Defaults to 15. | `15`
+`email_request_max_retries` | `int` | Number of retries for an email send after a network error, a rate limit, or an unavailable service. Defaults to 2. Set to 0 when a job runner already retries the send. | `2`
+`migrated_from` | `Optional[str]` | The email provider you moved from, such as `"resend"`. `emails` sends it with every request. | `None`
+`super_properties` |  | Properties merged into every captured event. | `None`
+`enable_exception_autocapture` |  | Automatically capture uncaught exceptions. | `False`
+`log_captured_exceptions` |  | Also log exceptions captured by error tracking. | `False`
+`project_root` |  | Root path used to determine in-app stack frames for captured exceptions. Defaults to the current working directory. | `None`
+`privacy_mode` |  | For AI observability, capture usage metadata without prompt inputs or outputs. | `False`
+`enable_full_ai_capture` |  | Route PostHog AI wrapper events through the dedicated AI capture endpoint and capture full AI content: skips string truncation and passes media (base64/data URIs) through unredacted. `privacy_mode` always wins. Defaults to False. | `False`
+`before_send` |  | Optional callback that can modify or drop events before upload. Return `None` to drop an event. | `None`
+`flag_fallback_cache_url` |  | Optional feature flag fallback cache URL, such as `memory://local/?ttl=300&size=10000` or a Redis URL. | `None`
+`enable_local_evaluation` |  | Whether to poll feature flag definitions for local evaluation when a personal API key is configured. | `True`
+`flag_definition_cache_provider` | `Optional[FlagDefinitionCacheProvider]` | Optional external cache provider for sharing feature flag definitions across workers. | `None`
+`capture_exception_code_variables` |  | Capture local variable values on exception stack frames. | `False`
+`capture_trace_context` |  | When OpenTelemetry is installed and a valid span is active at capture time, add its trace and span IDs as `$trace_id` and `$span_id` properties to events captured with `capture()` and `capture_ai()`, so they can be correlated with backend traces. Explicit `$trace_id`/`$span_id` values passed in `properties` win. Exception events (`capture_exception`) always attach these IDs regardless of this setting. Defaults to False. | `False`
+`traces` | `Optional[dict]` | Config dict for distributed tracing: `service_name`, `service_version`, `environment`, `resource_attributes`, `flush_interval` (5 s), `max_queue_size` (2048), `max_export_batch_size` (512), `max_live_spans` (10000), `max_span_age` (3600 s), `max_attributes_per_span` (128), `max_events_per_span` (128), `max_attribute_value_length` (8192). `before_span_send` is a callable, or a list run in order, that receives each finished span as a dict (`trace_id`, `span_id` and `parent_span_id` are read-only) and returns it, edited, or `None` to drop it; a hook that raises drops the span. Tracing is off until this is provided. Spans export on a background timer even with `sync_mode`; serverless handlers should call `flush()` before returning. Defaults to None. | `None`
+`code_variables_mask_patterns` |  | Variable-name patterns to mask when capturing code variables. | `None`
+`code_variables_ignore_patterns` |  | Variable-name patterns to omit when capturing code variables. | `None`
+`code_variables_mask_url_credentials` |  | Scrub credentials embedded in URLs/DSNs (e.g. `user:pass@host`) from captured code variables, regardless of the surrounding variable name. Defaults to True. | `None`
+`code_variables_detect_secrets` |  | Last-resort entropy-based detection that redacts high-entropy secret-looking values (API keys, tokens, strong passwords) sitting in innocuously-named variables, after the name and URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults to True. | `None`
+`in_app_modules` | `list[str] \| None` | Module/package prefixes treated as in-app frames in captured exceptions. | `None`
+`enable_exception_autocapture_rate_limiting` |  | Rate limit autocaptured exceptions client-side with a token bucket per exception type. Disabled by default. | `False`
+`exception_autocapture_bucket_size` |  | Maximum burst of autocaptured exceptions allowed per exception type (token bucket size, clamped to 0-100). | `DEFAULT_BUCKET_SIZE`
+`exception_autocapture_refill_rate` |  | Tokens restored per refill interval for each exception type's bucket. | `DEFAULT_REFILL_RATE`
+`exception_autocapture_refill_interval_seconds` |  | Seconds between token refills for autocaptured exception rate limiting. | `DEFAULT_REFILL_INTERVAL_SECONDS`
+`capture_mode` | `Optional[Union[CaptureMode, str]]` | Capture wire protocol to use. Defaults to `CaptureMode.V0` (legacy `/batch/`). Set `CaptureMode.V1` (or pass the string `"v1"`) to opt into `/i/v1/analytics/events`. When omitted, the `POSTHOG_CAPTURE_MODE` env var is consulted, then `V0`. | `None`
+`capture_compression` | `Optional[Union[CaptureCompression, str]]` | Request-body compression for capture-v1 uploads (ignored in V0, which uses `gzip`). `CaptureCompression.GZIP` or `DEFLATE` (or the strings `"gzip"`/`"deflate"`). When omitted, the `POSTHOG_CAPTURE_COMPRESSION` env var is consulted, then the legacy `gzip` flag, then no compression. | `None`
+
+**Examples:**
+
+```python
+from posthog import Posthog
+
+posthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')
+```
+
+## Capture
+
+### `Client.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to capture. | *required*
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to include with the event. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | A dictionary of group information. | 
+`flags` |  | A FeatureFlagEvaluations snapshot from evaluate_flags(). The exact values from the snapshot are attached with no extra /flags request. | 
+`send_feature_flags` |  | Deprecated. Prefer flags=... from evaluate_flags(). When truthy, evaluates flags during capture and attaches them to the event. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+# Anonymous event
+posthog.capture('some-anon-event')
+```
+```python
+# Context usage
+from posthog import identify_context, new_context
+with new_context():
+    identify_context('distinct_id_of_the_user')
+    posthog.capture('user_signed_up')
+    posthog.capture('user_logged_in')
+    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')
+```
+```python
+# Set event properties
+posthog.capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+```python
+# Page view event
+posthog.capture('$pageview', distinct_id="distinct_id_of_the_user", properties={'$current_url': 'https://example.com'})
+```
+
+## Identify
+
+### `Client.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+# Set with distinct id
+posthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+### `Client.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile only if they haven't been set before.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set once. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Traces
+
+### `Client.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on
+the way out); or call `end()` yourself for a span that cannot wrap a
+block. Spans started inside the block nest under it automatically.
+Always returns a usable handle, even when tracing is off, so calling
+code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. A forked child starts with no active span; pass the parent span to continue a trace across a fork. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+posthog = Posthog("<ph_project_api_key>", traces={"service_name": "checkout-api"})
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `Client.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes
+it active; a span started manually is not. Use it to propagate the
+trace to the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+## Alias
+
+### `Client.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+Create an alias between two distinct IDs.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The previous distinct ID. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`distinct_id` | `Optional[str]` | The new distinct ID to alias to. Falls back to the context distinct ID; the call is dropped with a warning if neither is available. | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+
+**Examples:**
+
+```python
+posthog.alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Capture AI
+
+### `Client.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size
+cap, batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`:
+the event UUID, or None when the event was not admitted (disabled
+client, or dropped by `before_send`). The event is queued on an
+isolated AI lane with its own consumer pool and a higher per-event
+size cap, posting to the dedicated AI ingestion endpoint. The payload
+is sent as given — no redaction or truncation is applied here.
+
+## Capture exception
+
+### `Client.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg], **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception for error tracking.
+
+When OpenTelemetry is installed and a valid span is active, its trace and
+span IDs are added as `$trace_id` and `$span_id` event properties.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. | *required*
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of additional properties. Overriding reserved exception properties is deprecated and will stop working in the next major version. | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. Attaches those exact flag values to the captured `$exception` event. | 
+`send_feature_flags` |  | Deprecated. Pass `flags` from `evaluate_flags()` instead. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+try:
+    # Some code that might fail
+    pass
+except Exception as e:
+    posthog.capture_exception(e, distinct_id='user_distinct_id', properties=additional_properties)
+```
+
+## Emails
+
+### `Client.emails`
+
+```python
+emails: Emails
+```
+
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
+scope. Sends go to `app_host`, or to the PostHog Cloud app host of
+`host`. `email_request_timeout_seconds` and `email_request_max_retries`
+configure each send. A disabled or shut-down client sends nothing. See
+`posthog.emails` for setup.
+
+**Examples:**
+
+```python
+client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+)
+```
+
+## Flush
+
+### `Client.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.
+
+For a client shared across requests or serverless invocations (including
+the module-level client), call `flush()` before a short-lived invocation
+returns. Use `shutdown()` instead only for final process cleanup or when
+disposing of a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after
+a timeout or span export failure, and failed events may be dropped by the
+consumers. Calls made directly from SDK callbacks such as `on_error` are
+deferred rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently. The span exporter waits up to this many seconds for an in-flight flush, then uses a fresh drain budget once it acquires the lock. If the lock wait times out, the in-flight flush is left to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. Each span request is bounded by the client's `timeout` in seconds, and the last request is not cut short. This is therefore not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the shared client open.
+posthog.flush(timeout_seconds=10)
+```
+
+## Get feature flag
+
+### `Client.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get multivariate feature flag value for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag payload
+
+### `Client.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, *, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload for a feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`match_value` | `Optional[FlagValue]` | The specific flag value to get payload for. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Deprecated. Use get_feature_flag() instead if you need events. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This method returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag result
+
+### `Client.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
+depending on whether local evaluation is enabled and the flag can be locally evaluated.
+This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+
+**Examples:**
+
+```python
+flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')
+if flag_result and flag_result.get_value() == 'variant-key':
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = flag_result.payload
+```
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagResult]` | Optional[FeatureFlagResult]: The feature flag result or None if disabled/not found.
+
+## Get feature flags
+
+### `Client.get_feature_variants`
+
+```python
+get_feature_variants(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Union[bool, str]]
+```
+
+Get feature flag variants for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+### `Client.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> Optional[dict[str, Union[bool, str]]]
+```
+
+Get all feature flags for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags('distinct_id_of_your_user')
+```
+
+## Get feature flags and payloads
+
+### `Client.get_feature_flags_and_payloads`
+
+```python
+get_feature_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get feature flags and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+result = posthog.get_feature_flags_and_payloads('<distinct_id>')
+```
+
+### `Client.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get all feature flags and their payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags_and_payloads('distinct_id_of_your_user')
+```
+
+## Evaluate flags
+
+### `Client.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[List[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+Local evaluation is transparent: when the poller resolves a flag, the
+snapshot's `$feature_flag_called` events are tagged `locally_evaluated=True`
+and reason `"Evaluated locally"`.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If True, never fall back to remote evaluation — flags that can't be evaluated locally are omitted from the snapshot and listed with a reason in its `unresolved_flags`. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[List[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is True. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagEvaluations` | A `FeatureFlagEvaluations` snapshot.
+
+**Examples:**
+
+```python
+flags = posthog.evaluate_flags(
+    "user_123",
+    person_properties={"plan": "enterprise"},
+)
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+## Group identify
+
+### `Client.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+Identify a group and set its properties.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | The type of group (e.g., 'company', 'team'). Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | The unique identifier for the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | A dictionary of properties to set on the group. | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[Union[str, UUID]]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user performing the action. | `None`
+
+**Examples:**
+
+```python
+posthog.group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Is feature enabled
+
+### `Client.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Check if a feature flag is enabled for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Shutdown
+
+### `Client.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.
+
+Failed or undrainable events may be dropped and reported through logging
+or `on_error`; returning does not guarantee server receipt. Lifecycle
+cleanup is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+posthog.join()
+```
+
+### `Client.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the client.
+
+Call this for final process cleanup or when disposing of a client that
+will not be reused. It closes capture lanes, stops background workers and
+the feature flag poller, and tears down integrations. Do not call it at the
+end of each request or serverless invocation when the client is shared;
+call `flush()` before returning instead. A shut-down client cannot be
+reused; create a new client if needed.
+
+Normally this method blocks until queued events have been attempted and
+cleanup finishes. Failed or undrainable events may be dropped and
+reported through logging or `on_error`; returning does not guarantee
+server receipt. Event draining has no timeout. Queued spans get one final
+flush with up to 30 seconds waiting for an in-flight flush, then a fresh
+30-second drain budget; the last HTTP request is not cut short. Any spans
+it cannot send are discarded with a warning, as are spans still open.
+Lifecycle cleanup is attempted once, and cleanup failures
+are logged without retry. When called directly from an SDK callback such as
+`on_error`, shutdown is deferred to avoid blocking the worker that
+invoked the callback. If the callback must coordinate a blocking
+shutdown, have it signal an
+application-owned thread and return before that thread calls shutdown.
+Do not wait inside the callback for another thread or task that calls a
+lifecycle method.
+
+**Examples:**
+
+```python
+posthog.shutdown()
+```
+
+## Flag definition loader
+
+### `Client.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flags for local evaluation.
+
+**Examples:**
+
+```python
+posthog.load_feature_flags()
+```
+
+### `Client.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Return feature flag definitions loaded for local evaluation.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The currently loaded feature flag definitions, or `None` before local evaluation has loaded definitions.
+
+## SDK utils
+
+### `Client.queue`
+
+```python
+queue: Queue
+```
+
+The analytics lane's queue (kept for backwards compatibility).
+
+### `Client.consumers`
+
+```python
+consumers: Optional[List[Consumer]]
+```
+
+Flat list of the lanes' consumers, analytics first (kept for backwards compatibility).
+
+### `Client.new_context`
+
+```python
+new_context(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+with client.new_context():
+    client.identify_context('<distinct_id>')
+    client.capture('event_name')
+```
+
+### `Client.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the wrapped function using this client.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+### `Client.tag`
+
+```python
+tag(name: str, value: Any) -> None
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key. | *required*
+`value` | `Any` | The tag value. | *required*
+
+### `Client.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context.
+
+### `Client.identify_context`
+
+```python
+identify_context(distinct_id: str) -> None
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_session`
+
+```python
+set_context_session(session_id: str) -> None
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str) -> None
+```
+
+Set the device ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children. | *required*
+
+### `Client.feature_flags`
+
+```python
+feature_flags
+```
+
+Get the local evaluation feature flags.
+
+### `Client.get_feature_payloads`
+
+```python
+get_feature_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Optional[str]]
+```
+
+Get feature flag payloads for a user, preserving valid serialized JSON.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+payloads = posthog.get_feature_payloads('<distinct_id>')
+```
+
+### `Client.get_flags_decision`
+
+```python
+get_flags_decision(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsResponse
+```
+
+Get feature flags decision.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+decision = posthog.get_flags_decision('user123')
+```
+
+### `Client.metrics`
+
+```python
+metrics: PostHogMetrics
+```
+
+The `posthog.metrics` API: a statsd-style pre-aggregating metrics client — alpha.
+
+Samples fold into per-series aggregates in memory and flush as one OTLP
+data point per series per window, so recording from hot paths is cheap.
+Configure via the `metrics` client option; pending metrics flush on
+`shutdown()`.
+
+**Examples:**
+
+```python
+client = Posthog("<ph_project_api_key>", metrics={"service_name": "billing-worker"})
+client.metrics.count("invoices.processed", 1, attributes={"plan": "pro"})
+client.metrics.gauge("queue.depth", 42)
+client.metrics.histogram("job.duration", 187, unit="ms")
+```
+
+### `Client.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The remote config feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag, or `None` if the client is disabled, no personal API key is configured, or the request fails. Encrypted payloads are decrypted by PostHog before being returned.
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires `secret_key` for authentication.
+
+</details>
+
+### `Client.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagEvaluationRuntime]` | The flag's evaluation runtime, or `None` when local evaluation has not loaded a definition for this key. A definition that carries no runtime reports `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+runtime = posthog.get_feature_flag_evaluation_runtime("my-flag")
+if runtime is FeatureFlagEvaluationRuntime.SERVER:
+    ...
+```
+
+### `Client.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime,
+so it is returned for `CLIENT` and for `SERVER`, and asking for
+`ALL` returns every loaded flag. Use this to decide which flags to hand
+to a browser when a backend serves flags to its own frontend.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`evaluation_runtime` | `Union[FeatureFlagEvaluationRuntime, str]` | The runtime to match, as a `FeatureFlagEvaluationRuntime` or its string value. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`list[str]` | The matching flag keys, in the order local evaluation loaded them. Empty when no definitions are loaded.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+client_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(
+    FeatureFlagEvaluationRuntime.CLIENT
+)
+```
+
+### `posthog.integrations.django.PosthogContextMiddleware`
+
+```python
+PosthogContextMiddleware(get_response)
+```
+
+Middleware to automatically track Django requests.
+
+This middleware wraps all calls with a posthog context. It attempts to extract the following from the request:
+- Session ID, (extracted from `X-POSTHOG-SESSION-ID`)
+- Distinct ID, (extracted from `X-POSTHOG-DISTINCT-ID`, falling back to the authenticated request user ID)
+- Authenticated user email as `email`
+- Request URL as `$current_url`
+- Request method as `$request_method`
+- Request path as `$request_path`
+- Forwarded IP address as `$ip`
+- User agent as `$user_agent`
+
+Configure the integration with these Django settings:
+- `POSTHOG_MW_CLIENT`: client used for automatic exception capture, or the global client.
+  This does not redirect events explicitly captured through other clients.
+- `POSTHOG_MW_CAPTURE_EXCEPTIONS`: `False` enables context enrichment only;
+  `True` enables automatic exception capture; `None` inherits the effective client's
+  `enable_exception_autocapture`. When omitted, the legacy default is `True`.
+- `POSTHOG_MW_REQUEST_FILTER`: a callback receiving the request. Returning `False`
+  disables both enrichment and automatic exception capture for that request.
+- `POSTHOG_MW_EXTRA_PROPERTIES`: a callback returning additional event properties.
+- `POSTHOG_MW_CAPTURE_TRACING_HEADERS`: read PostHog identity and session headers
+  as request-scoped analytics context (default: `True`). Explicit capture IDs and
+  event properties take precedence. These values are never authentication or
+  authorization. Authenticated Django user identity remains the fallback when no
+  usable header ID is available or header capture is disabled.
+- `POSTHOG_MW_TRUST_TRACING_HEADERS`: deprecated alias for
+  `POSTHOG_MW_CAPTURE_TRACING_HEADERS`; the capture-named setting takes precedence.
+- `POSTHOG_MW_PROPERTIES_MAP`: an optional callback transforming request properties.
+
+The old `POSTHOG_MW_EXTRA_TAGS` and `POSTHOG_MW_TAG_MAP` settings remain aliases;
+the property-named settings take precedence when both are configured.
+
+Request properties are included on all events captured within the active context,
+including when automatic exception capture is disabled.
+See the context documentation for more information. The extracted distinct ID and session ID,
+if found, are used to associate all events captured in the middleware context with the same distinct ID
+and session as currently active on the frontend. See the documentation for `set_context_session`
+and `identify_context` for more details.
+
+This middleware is hybrid-capable: it supports both WSGI (sync) and ASGI (async) Django applications. The middleware
+detects at initialization whether the next middleware in the chain is async or sync, and adapts its behavior accordingly.
+This ensures compatibility with both pure sync and pure async middleware chains, as well as mixed chains in ASGI mode.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`aextract_properties` | Async version of extract_properties for use in async request handling.
+`aextract_request_user` | Async version of extract_request_user for use in async request handling.
+`aextract_tags` | Compatibility alias for `aextract_properties`.
+`extract_properties` | Extract event properties and identity from a synchronous request.
+`extract_request_user` | Extract user ID and email from request in sync context.
+`extract_tags` | Compatibility alias for `extract_properties`.
+`process_exception` | Process exceptions from views and downstream middleware.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`async_capable` |  | 
+`capture_exceptions` | `Optional[bool]` | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`extra_tags` |  | Compatibility alias for `extra_properties`.
+`get_response` |  | 
+`properties_map` |  | 
+`request_filter` |  | 
+`sync_capable` |  | 
+`tag_map` |  | Compatibility alias for `properties_map`.
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+Initialize the middleware with Django's next handler.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`get_response` |  | The next middleware or view handler in Django's middleware chain. May be synchronous or asynchronous. | 
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_properties`
+
+```python
+async aextract_properties(request)
+```
+
+Async version of extract_properties for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_request_user`
+
+```python
+async aextract_request_user(request)
+```
+
+Async version of extract_request_user for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_tags`
+
+```python
+async aextract_tags(request)
+```
+
+Compatibility alias for `aextract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.async_capable`
+
+```python
+async_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_exceptions`
+
+```python
+capture_exceptions: Optional[bool] = capture_exceptions if (capture_exceptions is None or isinstance(capture_exceptions, bool)) else True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers, canonical_name='POSTHOG_MW_CAPTURE_TRACING_HEADERS', deprecated_name='POSTHOG_MW_TRUST_TRACING_HEADERS')
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.client`
+
+```python
+client = cast('Optional[Client]', settings.POSTHOG_MW_CLIENT)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_properties`
+
+```python
+extra_properties = cast('Callable[[HttpRequest], Dict[str, Any]]', extra_properties) if callable(extra_properties) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_tags`
+
+```python
+extra_tags
+```
+
+Compatibility alias for `extra_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_properties`
+
+```python
+extract_properties(request)
+```
+
+Extract event properties and identity from a synchronous request.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_request_user`
+
+```python
+extract_request_user(request)
+```
+
+Extract user ID and email from request in sync context.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_tags`
+
+```python
+extract_tags(request)
+```
+
+Compatibility alias for `extract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.get_response`
+
+```python
+get_response = get_response
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.process_exception`
+
+```python
+process_exception(request, exception)
+```
+
+Process exceptions from views and downstream middleware.
+
+Django calls this WHILE still inside the context created by __call__,
+so request tags have already been extracted and set. This method just
+needs to capture the exception directly.
+
+Django converts view exceptions into responses before they propagate through
+the middleware stack, so the context manager in __call__/__acall__ never sees them.
+
+Note: Django's process_exception is always synchronous, even for async views.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.properties_map`
+
+```python
+properties_map = cast('Callable[[Dict[str, Any]], Dict[str, Any]]', properties_map) if callable(properties_map) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.request_filter`
+
+```python
+request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.sync_capable`
+
+```python
+sync_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.tag_map`
+
+```python
+tag_map
+```
+
+Compatibility alias for `properties_map`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.flask.PosthogFlaskIntegration`
+
+```python
+PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog request context and exception tracking to a Flask app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `Optional[Flask]` | An optional Flask application. If omitted, call `init_app` later (the Flask application-factory pattern). | `None`
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions that reach Flask's unhandled exception machinery. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[Callable[[Request], bool]]` | Optional callback receiving Flask's request object. A false return value disables both context and exception capture for that request. | `None`
+`extra_properties` | `Optional[Callable[[Request], Mapping[str, Any]]]` | Optional callback returning additional event properties. This is useful for application-specific metadata such as an authenticated user's role. Values should not contain secrets or request bodies. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+The integration intentionally does not capture exceptions handled by an
+application error handler, expected HTTP exceptions, request or response
+bodies, query strings, cookies, authorization headers, or arbitrary headers.
+Call `capture_exception` explicitly from a custom error handler if a
+handled exception should be reported.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`init_app` | Register the integration with a Flask application once.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.init_app`
+
+```python
+init_app(app: Flask) -> None
+```
+
+Register the integration with a Flask application once.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.asgi.PosthogASGIMiddleware`
+
+```python
+PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: Optional[bool] = None, *, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog context and automatic exception capture to an ASGI app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `_ASGIApp` | The downstream ASGI application. | *required*
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions escaping the downstream app. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[_RequestFilter]` | Optional sync or async callback receiving the ASGI scope. Returning `False` bypasses all instrumentation for that scope. | `None`
+`extra_properties` | `Optional[_ExtraProperties]` | Optional sync or async callback receiving the ASGI scope and returning additional event properties. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`app` |  | 
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.app`
+
+```python
+app = app
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.celery.PosthogCeleryIntegration`
+
+```python
+PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
+```
+
+Celery integration that captures task lifecycle events and exceptions.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`client` | `Optional[Client]` | Optional `Client` instance. When provided, all events and exceptions are captured through this client rather than the global `posthog` module. Don't skip this if using a custom flag definition cache provider, and pass the custom `Client` instance here initialized with the custom provider so fork safety for that provider is handled correctly. | `None`
+`capture_exceptions` | `bool` | Whether to capture task exceptions via `capture_exception` (default `True`). | `True`
+`capture_task_lifecycle_events` | `bool` | Whether to emit lifecycle events of the task such as "started", "success", "failure" etc. (default `True`). | `True`
+`propagate_context` | `bool` | Whether to propagate PostHog context (distinct ID, session ID, tags) from the producer to the worker via task headers (default `True`). | `True`
+`task_filter` | `Optional[Callable[[Optional[str], dict[str, Any]], bool]]` | Optional callback `(task_name, task_properties) -> bool` expected to return `False` if a given task should not be tracked. | `None`
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`instrument` | Connect Celery signal handlers to capture task events and exceptions. Call this after initializing the PostHog client and this integration.
+`shutdown` | Disconnect all signal handlers registered by `instrument()`, flush all pending events and cleanly shutdown the integration.
+`uninstrument` | Disconnect Celery signal handlers and unregister exit cleanup.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_task_lifecycle_events` |  | 
+`client` |  | 
+`propagate_context` |  | 
+`task_filter` |  | 
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_task_lifecycle_events`
+
+```python
+capture_task_lifecycle_events = capture_task_lifecycle_events
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.instrument`
+
+```python
+instrument() -> None
+```
+
+Connect Celery signal handlers to capture task events and exceptions.
+Call this after initializing the PostHog client and this integration.
+
+If Celery runs on a single host, reinstrumenting in worker children is
+not strictly necessary because the PostHog client and this integration
+are fork-safe. If Celery workers run across multiple hosts, each worker
+process must initialize PostHog, this integration, and call
+`instrument()`. Celery provides `worker_process_init` signal to help
+with this.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.propagate_context`
+
+```python
+propagate_context = propagate_context
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Disconnect all signal handlers registered by `instrument()`, flush all pending events
+and cleanly shutdown the integration.
+
+`shutdown()` is also registered on `worker_process_shutdown` and `atexit` signals,
+but there is no guarantee those will always be called, so we strongly recommend calling
+it manually when the integration is no longer needed to avoid data loss.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.task_filter`
+
+```python
+task_filter = task_filter
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.uninstrument`
+
+```python
+uninstrument() -> None
+```
+
+Disconnect Celery signal handlers and unregister exit cleanup.
+
+Do not use directly, call `shutdown()` instead.
+
+### `posthog.request.set_socket_options`
+
+```python
+set_socket_options(socket_options: Optional[SocketOptions]) -> None
+```
+
+Configure socket options for all SDK HTTP connections.
+
+Call this during initialization, before making API requests. Pass `None`
+to reset to the default socket behavior.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`socket_options` | `Optional[SocketOptions]` | A list of `(level, option, value)` tuples accepted by urllib3/`socket.setsockopt()`, or `None` to reset defaults. | *required*
+
+<details class="example" open markdown="1">
+<summary>Example</summary>
+
+from posthog import set_socket_options
+set_socket_options([(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)])
+
+</details>
+
+### `posthog.request.enable_keep_alive`
+
+```python
+enable_keep_alive() -> None
+```
+
+Enable TCP keepalive for SDK HTTP connections.
+
+This helps prevent idle pooled connections from being dropped by network
+infrastructure. Call during initialization, before making API requests.
+
+### `posthog.request.disable_connection_reuse`
+
+```python
+disable_connection_reuse() -> None
+```
+
+Disable HTTP connection reuse for SDK requests.
+
+Each request will create a fresh connection. This can avoid issues with
+environments that terminate pooled connections, but adds per-request
+overhead. Call during initialization, before making API requests.
+
+## AsyncClient
+
+Needs the `async` extra, `posthog[async]`.
+
+### `AsyncClient(...)`
+
+```python
+AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None) -> None
+```
+
+### `AsyncClient.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Queue an event without blocking for network delivery.
+
+### `AsyncClient.capture_immediate`
+
+```python
+async capture_immediate(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture one event and wait until its delivery attempt completes.
+
+### `AsyncClient.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+### `AsyncClient.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception. This method never raises, including in debug mode.
+
+### `AsyncClient.emails`
+
+```python
+emails: AsyncEmails
+```
+
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
+scope, and `posthog[async]`. Sends go to `app_host`, or to the PostHog
+Cloud app host of `host`. `email_request_timeout_seconds` and
+`email_request_max_retries` configure each send. A disabled or shut-down
+client sends nothing. See `posthog.emails` for setup.
+
+**Examples:**
+
+```python
+await client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    distinct_id="user_123",
+)
+```
+
+### `AsyncClient.flush`
+
+```python
+async flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+### `AsyncClient.evaluate_flags`
+
+```python
+async evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate flags remotely without blocking the event loop.
+
+The returned snapshot has synchronous in-memory accessors. Pass it to
+`capture(flags=...)` to attach the exact values used for branching.
+This client does not evaluate flags locally, so the snapshot's
+`unresolved_flags` is always empty.
+
+### `AsyncClient.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+### `AsyncClient.shutdown`
+
+```python
+async shutdown() -> None
+```
+
+### `AsyncClient.join`
+
+```python
+async join() -> None
+```
+
+### `AsyncClient.get_remote_config_payload`
+
+```python
+async get_remote_config_payload(key: str) -> Optional[Any]
+```
+
+Fetch and decrypt a remote-config payload without blocking the loop.
+
+## Module functions
+
+### `posthog.new_context`
+
+```python
+new_context(fresh: bool = False, capture_exceptions: Optional[bool] = None, client: Optional[Client] = None)
+```
+
+Create a new context scope that will be active for the duration of the with block.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` | `bool` | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting. | `None`
+`client` | `Optional[Client]` | Optional Posthog client instance to use for this context (default: None) | `None`
+
+**Examples:**
+
+```python
+from posthog import new_context, tag, capture
+with new_context():
+    tag("request_id", "123")
+    capture("event_name", properties={"property": "value"})
+```
+
+### `posthog.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the function.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+from posthog import scoped, tag, capture
+@scoped()
+def process_payment(payment_id):
+    tag("payment_id", payment_id)
+    capture("payment_started")
+```
+
+### `posthog.set_context_session`
+
+```python
+set_context_session(session_id: str)
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_session
+set_context_session("session_123")
+```
+
+### `posthog.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str)
+```
+
+Set the device ID for the current context, associating all feature flag requests
+in this or child contexts with the given device ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_device_id
+set_context_device_id("device_123")
+```
+
+### `posthog.identify_context`
+
+```python
+identify_context(distinct_id: str)
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import identify_context
+identify_context("user_123")
+```
+
+### `posthog.set_capture_exception_code_variables_context`
+
+```python
+set_capture_exception_code_variables_context(enabled: bool)
+```
+
+Override code-variable capture for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`enabled` | `bool` | Whether exceptions captured in this context should include local variable values from stack frames. | *required*
+
+### `posthog.set_code_variables_mask_patterns_context`
+
+```python
+set_code_variables_mask_patterns_context(mask_patterns: list[str])
+```
+
+Override code-variable mask patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`mask_patterns` | `list[str]` | Variable-name patterns whose values should be replaced with `***` when code variables are captured. | *required*
+
+### `posthog.set_code_variables_ignore_patterns_context`
+
+```python
+set_code_variables_ignore_patterns_context(ignore_patterns: list[str])
+```
+
+Override code-variable ignore patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`ignore_patterns` | `list[str]` | Variable-name patterns that should be omitted entirely when code variables are captured. | *required*
+
+### `posthog.set_code_variables_mask_url_credentials_context`
+
+```python
+set_code_variables_mask_url_credentials_context(enabled: bool)
+```
+
+Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from
+captured code variables for the current context.
+
+### `posthog.set_code_variables_detect_secrets_context`
+
+```python
+set_code_variables_detect_secrets_context(enabled: bool)
+```
+
+Whether to apply entropy-based secret detection as a last-resort redaction of
+high-entropy values (API keys, tokens, strong passwords) in captured code
+variables for the current context.
+
+### `posthog.tag`
+
+```python
+tag(name: str, value: Any)
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key | *required*
+`value` | `Any` | The tag value | *required*
+
+**Examples:**
+
+```python
+from posthog import tag
+tag("user_id", "123")
+```
+
+### `posthog.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context
+
+### `posthog.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture anything a user does within your system.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to specify the event | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional arguments including: distinct_id: Unique identifier for the user properties: Dict of event properties timestamp: When the event occurred. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this event. If omitted, one is generated     and returned. If provided, it must be a valid UUID string or     uuid.UUID instance; invalid values are ignored and replaced with     a newly generated UUID. groups: Dict of group types and IDs flags: A FeatureFlagEvaluations snapshot from evaluate_flags(). The     exact values from the snapshot are attached with no extra /flags     request. send_feature_flags: Deprecated. Prefer flags=... from     evaluate_flags(). When truthy, evaluates flags during capture and     attaches them to the event. disable_geoip: Whether to disable GeoIP lookup | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.
+
+</details>
+
+**Examples:**
+
+```python
+# Context and capture usage
+from posthog import new_context, identify_context, tag, capture
+# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)
+with new_context():
+    # Associate this context with some user, by distinct_id
+    identify_context('some user')
+
+    # Capture an event, associated with the context-level distinct ID ('some user')
+    capture('movie started')
+
+    # Capture an event associated with some other user (overriding the context-level distinct ID)
+    capture('movie joined', distinct_id='some-other-user')
+
+    # Capture an event with some properties
+    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})
+
+    # Capture an event with some properties
+    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})
+    # Capture an event with some associated group
+    capture('purchase', groups={'company': 'id:5'})
+
+    # Adding a tag to the current context will cause it to appear on all subsequent events
+    tag('some-tag', 'some-value')
+
+    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict
+```
+```python
+# Set event properties
+from posthog import capture
+capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+
+### `posthog.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size cap,
+batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`: the
+event UUID, or None when the event was not admitted (disabled client, or
+dropped by `before_send`). The event is delivered on an isolated queue
+with its own consumer pool and a higher per-event size cap, posting to
+the dedicated AI ingestion endpoint. The payload is sent as given — no
+redaction or truncation is applied here.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name, normally one of the `$ai_*` event names. | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Same optional arguments as `capture()`. | `{}`
+
+**Examples:**
+
+```python
+from posthog import capture_ai
+
+uuid = capture_ai(
+    "$ai_generation",
+    distinct_id="user_123",
+    properties={"$ai_model": "gpt-5"},
+)
+```
+
+### `posthog.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).
+
+</details>
+
+**Examples:**
+
+```python
+# Set person properties
+from posthog import set
+set(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})
+```
+
+### `posthog.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record, only if they do not yet exist.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set only once. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.
+
+</details>
+
+**Examples:**
+
+```python
+# Set property once
+from posthog import set_once
+set_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})
+
+```
+
+### `posthog.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+Set properties on a group.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | Type of your group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | Unique identifier of the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | Properties to set on the group | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`distinct_id` | `Optional[ID_TYPES]` | Optional distinct ID of the user performing the action | `None`
+
+**Examples:**
+
+```python
+# Group identify
+from posthog import group_identify
+group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+### `posthog.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: str, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The unique ID of the user before | *required*
+`distinct_id` | `str` | The current unique id | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like "Which marketing channels leads to users churning after a month?" or "What do users do on our website before signing up?". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+</details>
+
+**Examples:**
+
+```python
+# Alias user
+from posthog import alias
+alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+### `posthog.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture exceptions that happen in your code.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. If not provided, the current exception is captured via `sys.exc_info()` | `None`
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional capture arguments including distinct_id, properties, timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip. Overriding reserved exception properties through `properties` is deprecated and will stop working in the next major version. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the "traceback"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError("Some Error"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.
+
+</details>
+
+**Examples:**
+
+```python
+# Capture exception
+from posthog import capture_exception
+try:
+    risky_operation()
+except Exception as e:
+    capture_exception(e)
+```
+
+### `posthog.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Use feature flags to enable or disable features for users.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.
+
+</details>
+
+**Examples:**
+
+```python
+# Boolean feature flag
+from posthog import feature_enabled, get_feature_flag_payload
+is_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get feature flag variant for users. Used with experiments.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping from group type to group key | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties in format { group_type_name: { group_properties } } | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+`groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5", you would pass groups={"organization": "5"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count, you'll send these as: group_properties={"organization": {"name": "PostHog", "employees": 11}}.
+
+</details>
+
+**Examples:**
+
+```python
+# Multivariate feature flag
+from posthog import get_feature_flag, get_feature_flag_payload
+enabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key':
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> Optional[dict[str, FlagValue]]
+```
+
+Get all flags for a given user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate (evaluates all if None) | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.
+
+</details>
+
+**Examples:**
+
+```python
+# All flags for user
+from posthog import get_all_flags
+get_all_flags('distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload.
+
+This method evaluates a feature flag and returns a FeatureFlagResult object containing:
+- enabled: Whether the flag is enabled
+- variant: The variant value if the flag has variants
+- payload: The payload associated with the flag (automatically deserialized from JSON)
+- key: The flag key
+- reason: Why the flag was enabled/disabled
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+Example:
+```python
+result = posthog.get_feature_flag_result('beta-feature', 'distinct_id')
+if result and result.enabled:
+    # Use the variant and payload
+    print(f"Variant: {result.variant}")
+    print(f"Payload: {result.payload}")
+```
+
+### `posthog.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload associated with a feature flag value.
+
+Deprecated for new code. Prefer `evaluate_flags()` and
+`flags.get_flag_payload(key)` so flag evaluation happens once per request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`match_value` | `Optional[FlagValue]` | Optional flag value to use when selecting a payload. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This function returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+### `posthog.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The key of the feature flag | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag. If payload is encrypted, the return value will be decrypted
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires secret_key to be set for authentication
+
+</details>
+
+### `posthog.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> FlagsAndPayloads
+```
+
+Get all feature flag values and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate. Evaluates all flags when omitted. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FlagsAndPayloads` | A dict with `featureFlags` and `featureFlagPayloads` entries.
+
+### `posthog.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture()` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If `True`, never fall back to remote evaluation and omit flags that cannot be evaluated locally. The snapshot's `unresolved_flags` lists them with a reason. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[list[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is `True`. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Examples:**
+
+```python
+from posthog import evaluate_flags, capture
+flags = evaluate_flags("user_123", person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+### `posthog.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Returns loaded feature flags.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import feature_flag_definitions
+definitions = feature_flag_definitions()
+```
+
+### `posthog.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Reads the `evaluation_runtime` each flag definition carries, so no extra
+request is made. Returns `None` when local evaluation has not loaded a
+definition for this key. A definition that carries no runtime reports
+`FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime
+runtime = get_feature_flag_evaluation_runtime("my-flag")
+```
+
+### `posthog.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so
+it is returned for `CLIENT` and for `SERVER`. Use this to decide which
+flags to hand to a browser when a backend serves flags to its own
+frontend.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime
+client_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)
+```
+
+### `posthog.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flag definitions from PostHog.
+
+**Examples:**
+
+```python
+from posthog import load_feature_flags
+load_feature_flags()
+```
+
+### `posthog.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.
+
+Call `flush()` before a short-lived request or serverless invocation returns
+when using the shared module-level client. Use `shutdown()` only for final
+process cleanup or a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after a
+timeout or span export failure, and failed events may be dropped by consumers.
+Calls made directly from SDK callbacks such as `on_error` are deferred
+rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently, waiting up to this many seconds for an in-flight flush before starting a fresh drain budget. A lock wait timeout leaves the in-flight flush to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. The last span request is not cut short and is bounded by the client's `timeout` in seconds, so this is not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+import posthog
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the global client open.
+posthog.flush(timeout_seconds=10)
+```
+
+### `posthog.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.
+
+Failed or undrainable events may be dropped and reported through logging or
+`on_error`; returning does not guarantee server receipt. Lifecycle cleanup
+is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+from posthog import join
+join()
+```
+
+### `posthog.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime.datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on the
+way out); or call `end()` yourself for a span that cannot wrap a block.
+Spans started inside the block nest under it automatically. Always returns
+a usable handle, even when tracing is off, so calling code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+import posthog
+posthog.traces = {"service_name": "checkout-api"}
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `posthog.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes it
+active; a span started manually is not. Use it to propagate the trace to
+the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+### `posthog.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the global client.
+
+Call this for final process cleanup, not at the end of each request or
+serverless invocation that shares the module-level client. Use `flush()`
+before returning from those invocations instead. Shutdown closes capture
+lanes, stops background workers and the feature flag poller, and tears down
+integrations. The global client is not recreated automatically after shutdown.
+
+This normally blocks until queued events have been attempted and cleanup
+finishes. Failed or undrainable events may be dropped and reported through
+logging or `on_error`; returning does not guarantee server receipt. Event
+draining has no timeout. Queued spans get a final flush with up to 30 seconds
+waiting for an in-flight flush, then a fresh 30-second drain budget; the last
+HTTP request is not cut short. Unsent queued spans and still-open spans are
+discarded with a warning.
+Lifecycle cleanup is attempted once, and cleanup failures are logged without
+retry. Calls made directly from SDK callbacks such as `on_error` are deferred
+to avoid deadlocking the worker. If blocking completion is required, signal an application-owned
+thread, return from the callback, and call `shutdown()` from that thread.
+Do not wait inside a callback for another thread or task calling a lifecycle
+method.
+
+**Examples:**
+
+```python
+from posthog import shutdown
+shutdown()
+```
+
+### `posthog.setup`
+
+```python
+setup() -> Client
+```
+
+Create or return the global PostHog client configured by module settings.
+
+Most applications should either instantiate `Posthog` directly or set
+`posthog.api_key`/other module settings before calling top-level helpers.
+`setup()` is called automatically by global APIs such as `capture()`.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Client` | The global `Client` instance. If both `api_key` and `project_api_key` are missing or blank, the client is disabled and module-level calls become no-ops.
+
+## Types
+
+### `OptionalCaptureArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the capture method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the person associated with this event. If not set, the context distinct_id is used, if available, otherwise a UUID is generated, and the event is marked as personless. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to track with the event | 
+`timestamp` |  | When the event occurred (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this specific event. If not provided, one is generated. The event UUID is returned, so you can correlate it with actions in your app (like showing users an error ID if you capture an exception). If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | Group identifiers to associate with this event (format: {group_type: group_key}) | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. The exact flag values from the snapshot are attached to the event with no additional network call — prefer this over `send_feature_flags`. | 
+`send_feature_flags` |  | Deprecated — prefer `flags` with a `FeatureFlagEvaluations` snapshot. Whether to include currently active feature flags in the event properties. Can be a boolean or a SendFeatureFlagsOptions object. Defaults to False. Fires a hidden `/flags` request on capture and may return different values than the ones the code branched on. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this event. Defaults to False. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`flags` | `NotRequired[Optional[FeatureFlagEvaluations]]` | 
+`groups` | `NotRequired[Optional[Dict[str, str]]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`send_feature_flags` | `NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalCaptureArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.flags`
+
+```python
+flags: NotRequired[Optional[FeatureFlagEvaluations]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.groups`
+
+```python
+groups: NotRequired[Optional[Dict[str, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.send_feature_flags`
+
+```python
+send_feature_flags: NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
+
+### `FeatureFlagEvaluations`
+
+```python
+FeatureFlagEvaluations(host: _FeatureFlagEvaluationsHost, distinct_id: str, flags: Dict[str, _EvaluatedFlagRecord], groups: Optional[Mapping[str, Union[str, int]]] = None, disable_geoip: Optional[bool] = None, request_id: Optional[str] = None, evaluated_at: Optional[int] = None, errors_while_computing: bool = False, quota_limited: bool = False, minimal_flag_called_events: bool = False, accessed: Optional[Set[str]] = None, unresolved_flags: Optional[Mapping[str, UnresolvedFlagReason]] = None) -> None
+```
+
+A point-in-time snapshot of feature flag evaluations for a single distinct_id.
+
+Returned by `Client.evaluate_flags` — branch on `is_enabled` /
+`get_flag` and pass the same object to `Client.capture` via the
+`flags` option so the captured event carries the exact flag values the code
+branched on.
+
+```python
+flags = posthog.evaluate_flags(distinct_id, person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id=distinct_id, flags=flags)
+```
+
+To narrow the set of flags that get attached to a captured event, use the in-memory
+helpers `only` and `only_accessed`. To narrow the set of flags requested
+from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`get_flag` | Return the flag value. Fires `$feature_flag_called` on first access.
+`get_flag_payload` | Return the payload associated with a flag.
+`is_enabled` | Return whether the flag is enabled. Fires `$feature_flag_called` on the first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+`only` | Return a filtered copy containing only flags with the given keys. Keys that are not present in the evaluation are dropped and logged as a warning.
+`only_accessed` | Return a filtered copy containing only flags accessed via `is_enabled` or `get_flag` before this call.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`keys` | `List[str]` | Return the flag keys that are part of this evaluation.
+`unresolved_flags` | `Mapping[str, UnresolvedFlagReason]` | Return a read-only mapping of flag key to the reason local evaluation left it without a value.
+
+Internal — instances are created by the SDK via `Client.evaluate_flags()`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag`
+
+```python
+get_flag(key: str, *, send_feature_flag_events: bool = True) -> Optional[FlagValue]
+```
+
+Return the flag value. Fires `$feature_flag_called` on first access.
+
+Returns the variant string for multivariate flags, `True` for enabled flags
+without a variant, `False` for disabled flags, and `None` for flags that
+were not returned by the evaluation.
+
+Pass `send_feature_flag_events=False` to skip the event for this read, as
+with `is_enabled`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag_payload`
+
+```python
+get_flag_payload(key: str) -> Optional[Any]
+```
+
+Return the payload associated with a flag.
+
+Does not count as an access for `only_accessed` and does not fire any event.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.is_enabled`
+
+```python
+is_enabled(key: str, default_value: bool = False, *, send_feature_flag_events: bool = True) -> bool
+```
+
+Return whether the flag is enabled. Fires `$feature_flag_called` on the
+first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`default_value` | `bool` | Returned when the flag has no value in this evaluation — the key was not part of the evaluated set, or the evaluation itself came back empty (failed `/flags` request, quota limit, or no resolvable `distinct_id`). Defaults to `False`. | `False`
+`send_feature_flag_events` | `bool` | Whether this read sends `$feature_flag_called`. When `False`, no event is sent and the dedupe cache is left alone, but the key still counts as accessed for `only_accessed`. | `True`
+
+A flag that has a value always wins over `default_value`, including a
+disabled flag, which returns `False` even when `default_value=True`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.keys`
+
+```python
+keys: List[str]
+```
+
+Return the flag keys that are part of this evaluation.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only`
+
+```python
+only(keys: List[str]) -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags with the given keys. Keys that
+are not present in the evaluation are dropped and logged as a warning.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only_accessed`
+
+```python
+only_accessed() -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags accessed via `is_enabled`
+or `get_flag` before this call.
+
+Order-dependent: if nothing has been accessed yet, the returned snapshot is
+empty. The method honors its name — pre-access if you want a populated result.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.unresolved_flags`
+
+```python
+unresolved_flags: Mapping[str, UnresolvedFlagReason]
+```
+
+Return a read-only mapping of flag key to the reason local evaluation
+left it without a value.
+
+A flag is listed when it has a loaded local definition, was in the requested
+scope, was inconclusive locally, and no remote value filled the gap. Listed
+flags are not part of `keys`, and reading one reports the
+`local_evaluation_inconclusive` error instead of `flag_missing`. Reading
+this mapping does not count as an access and does not fire any event.
+Snapshots returned by `only` and `only_accessed`, and by
+`AsyncClient.evaluate_flags()`, which evaluates only remotely, carry no
+entries.
+
+### `FeatureFlagResult`
+
+```python
+FeatureFlagResult(key: str, enabled: bool, variant: Optional[str], payload: Optional[Any], reason: Optional[str]) -> None
+```
+
+The result of calling a feature flag which includes the flag result, variant, and payload.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | The unique identifier of the feature flag.
+`enabled` | `bool` | Whether the feature flag is enabled for the current context.
+`variant` | `Optional[str]` | The variant value if the flag is enabled and has variants, None otherwise.
+`payload` | `Optional[Any]` | Additional data associated with the feature flag, if any.
+`reason` | `Optional[str]` | A description of why the flag was enabled or disabled, if available.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_flag_details` | Create a FeatureFlagResult from a FeatureFlag object.
+`from_value_and_payload` | Creates a FeatureFlagResult from a flag value and payload.
+`get_value` | Returns the value of the flag. This is the variant if it exists, otherwise the enabled value. This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+#### `posthog.types.FeatureFlagResult.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlagResult.from_flag_details`
+
+```python
+from_flag_details(details: Union[FeatureFlag, None], override_match_value: Optional[FlagValue] = None) -> FeatureFlagResult | None
+```
+
+Create a FeatureFlagResult from a FeatureFlag object.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`details` | `Union[FeatureFlag, None]` | The FeatureFlag object to convert. | *required*
+`override_match_value` | `Optional[FlagValue]` | If provided, this value will be used to populate the enabled and variant fields instead of the values from the FeatureFlag. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagResult \| None` | FeatureFlagResult | None: A new FeatureFlagResult instance, or None if details is None.
+
+#### `posthog.types.FeatureFlagResult.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: Union[FlagValue, None], payload: Any) -> Union[FeatureFlagResult, None]
+```
+
+Creates a FeatureFlagResult from a flag value and payload.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The unique identifier of the feature flag. | *required*
+`value` | `Union[FlagValue, None]` | The value of the flag (string variant or boolean). | *required*
+`payload` | `Any` | Additional data associated with the feature flag. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Union[FeatureFlagResult, None]` | Union[FeatureFlagResult, None]: A new FeatureFlagResult instance, or None if value is None.
+
+#### `posthog.types.FeatureFlagResult.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Returns the value of the flag. This is the variant if it exists, otherwise the enabled value.
+This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+**Returns:**
+
+Name | Type | Description
+---- | ---- | -----------
+`FlagValue` | `FlagValue` | Either a string variant or boolean value representing the flag's state.
+
+#### `posthog.types.FeatureFlagResult.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlagResult.payload`
+
+```python
+payload: Optional[Any]
+```
+
+#### `posthog.types.FeatureFlagResult.reason`
+
+```python
+reason: Optional[str]
+```
+
+#### `posthog.types.FeatureFlagResult.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FeatureFlag`
+
+```python
+FeatureFlag(key: str, enabled: bool, variant: Optional[str], reason: Optional[FlagReason], metadata: Union[FlagMetadata, LegacyFlagMetadata]) -> None
+```
+
+Detailed feature flag evaluation returned by the flags API.
+
+`enabled`, `variant` and `metadata.payload` are the value rendered the way
+responses before `/flags?v=4` carried it, which the legacy getters return.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | Feature flag key.
+`enabled` | `bool` | Whether the flag is enabled for the evaluated user or group.
+`variant` | `Optional[str]` | Variant key for multivariate flags, otherwise `None`.
+`reason` | `Optional[FlagReason]` | Optional reason metadata explaining the result.
+`metadata` | `Union[FlagMetadata, LegacyFlagMetadata]` | Payload and other metadata returned by the API.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_json` | Parse one flag record of a `/flags` response.
+`from_value_and_payload` | Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+`get_value` | Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlag.from_json`
+
+```python
+from_json(resp: Any) -> FeatureFlag
+```
+
+Parse one flag record of a `/flags` response.
+
+A record with a `value` member is a `/flags?v=4` record. A record
+without one comes from an older server: its value is `variant`, or
+`enabled` when there is no variant, and its config version is `1`.
+
+#### `posthog.types.FeatureFlag.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: FlagValue, payload: Any) -> FeatureFlag
+```
+
+Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+
+#### `posthog.types.FeatureFlag.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlag.metadata`
+
+```python
+metadata: Union[FlagMetadata, LegacyFlagMetadata]
+```
+
+#### `posthog.types.FeatureFlag.reason`
+
+```python
+reason: Optional[FlagReason]
+```
+
+#### `posthog.types.FeatureFlag.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FlagsAndPayloads`
+
+Bases: `TypedDict`
+
+Feature flag values and payloads keyed by feature flag key.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`featureFlags` | `Optional[dict[str, FlagValue]]` | Each flag's value, keyed by flag key.
+`featureFlagPayloads` | `Optional[dict[str, Any]]` | Each flag's payload, keyed by flag key.
+
+#### `posthog.types.FlagsAndPayloads.featureFlagPayloads`
+
+```python
+featureFlagPayloads: Optional[dict[str, Any]]
+```
+
+#### `posthog.types.FlagsAndPayloads.featureFlags`
+
+```python
+featureFlags: Optional[dict[str, FlagValue]]
+```
+
+### `UnresolvedFlagReason`
+
+Bases: `str`, `Enum`
+
+Why local evaluation left a flag without a value.
+
+Reported by `FeatureFlagEvaluations.unresolved_flags`. Inheriting from
+`str` keeps the members directly comparable to their string values. When more
+than one cause applies, the first reason in the order below is reported.
+
+<details class="values" open markdown="1">
+<summary>Values</summary>
+
+EXPERIENCE_CONTINUITY: The flag has experience continuity enabled, which
+    local evaluation never resolves. Change the flag to fix it.
+UNSUPPORTED_DEFINITION: The flag uses something the local evaluator does not
+    support, such as a static cohort, an unknown operator, a malformed value,
+    a dependency with no loaded definition or a circular dependency. Change
+    the flag or upgrade the SDK to fix it.
+UNRESOLVED_DEPENDENCY: A flag this flag depends on has a loaded definition
+    but was unresolved.
+MISSING_CONTEXT: The call did not pass a property, group property or device
+    id the flag needs, or passed it in an unusable form. Pass it to fix it.
+
+</details>
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`EXPERIENCE_CONTINUITY` |  | 
+`MISSING_CONTEXT` |  | 
+`UNRESOLVED_DEPENDENCY` |  | 
+`UNSUPPORTED_DEFINITION` |  | 
+
+#### `posthog.types.UnresolvedFlagReason.EXPERIENCE_CONTINUITY`
+
+```python
+EXPERIENCE_CONTINUITY = 'experience_continuity'
+```
+
+#### `posthog.types.UnresolvedFlagReason.MISSING_CONTEXT`
+
+```python
+MISSING_CONTEXT = 'missing_context'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNRESOLVED_DEPENDENCY`
+
+```python
+UNRESOLVED_DEPENDENCY = 'unresolved_dependency'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNSUPPORTED_DEFINITION`
+
+```python
+UNSUPPORTED_DEFINITION = 'unsupported_definition'
+```
+
+### `InconclusiveMatchError`
+
+```python
+InconclusiveMatchError(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when local evaluation can't determine a flag's value. `reason` says
+why, as reported by `FeatureFlagEvaluations.unresolved_flags`.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why local evaluation couldn't resolve the flag.
+
+#### `posthog.feature_flags.InconclusiveMatchError.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `RequiresServerEvaluation`
+
+```python
+RequiresServerEvaluation(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when feature flag evaluation requires server-side data that is not
+available locally (e.g., static cohorts).
+
+This error should propagate immediately to trigger API fallback, unlike
+InconclusiveMatchError which allows trying other conditions.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why the flag needs server-side evaluation.
+
+#### `posthog.feature_flags.RequiresServerEvaluation.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `Span`
+
+A handle to a span.
+
+Every method is safe to call on any handle, including after `end()` and
+on the inert handles returned when tracing is off, so calling code never
+branches on whether tracing is running. Entering a handle (`with span:`)
+makes it the active span for the block and ends it on exit, recording an
+`Exception` raised inside it. A `BaseException` that is not an
+`Exception` (`GeneratorExit`, `CancelledError`, `KeyboardInterrupt`)
+still ends the span but is not recorded as a failure.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`add_event` | Add a timestamped event to the span. Ignored after `end()`.
+`end` | End the span and queue it for export. Idempotent.
+`record_exception` | Record an exception as an `exception` event and mark the span `error`.
+`set_attribute` | Set one attribute on the span; last write wins. Ignored after `end()`.
+`set_attributes` | Set several attributes at once; last write wins per key. Ignored after `end()`.
+`set_status` | Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+`traceparent` | The W3C `traceparent` header value to propagate, or `None`.
+`tracestate` | The W3C `tracestate` header value to propagate, or `None`.
+`update_name` | Rename the span, for a name only known after it started. Ignored after `end()`.
+
+#### `posthog.tracing.span.Span.add_event`
+
+```python
+add_event(name: str, attributes: Optional[Mapping[str, Any]] = None, timestamp: Union[datetime, float, None] = None) -> Span
+```
+
+Add a timestamped event to the span. Ignored after `end()`.
+
+`timestamp` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`. Returns the span, so calls
+chain.
+
+**Examples:**
+
+```python
+span.add_event("cache.miss", {"key": "user:42"})
+```
+
+#### `posthog.tracing.span.Span.end`
+
+```python
+end(end_time: Union[datetime, float, None] = None) -> None
+```
+
+End the span and queue it for export. Idempotent.
+
+`end_time` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`, and is never earlier than
+the start. Later calls, and later mutations, no-op. `with span:`
+ends the span on exit, so call this only for spans started manually.
+
+**Examples:**
+
+```python
+span = posthog.start_span("job")
+try:
+    run_job()
+finally:
+    span.end()
+```
+
+#### `posthog.tracing.span.Span.record_exception`
+
+```python
+record_exception(exception: BaseException) -> Span
+```
+
+Record an exception as an `exception` event and mark the span `error`.
+
+Ignored after `end()`. The event carries `exception.type`,
+`exception.message` and, for a raised exception,
+`exception.stacktrace` (its last `max_attribute_value_length`
+characters, so a chained traceback keeps the outermost exception and
+may lose its cause). Returns the span, so calls chain. Inside
+`with span:` a raised `Exception` is recorded automatically, so
+this is for exceptions that are caught and handled.
+
+**Examples:**
+
+```python
+try:
+    charge(card)
+except PaymentError as e:
+    span.record_exception(e)
+```
+
+#### `posthog.tracing.span.Span.set_attribute`
+
+```python
+set_attribute(key: str, value: Any) -> Span
+```
+
+Set one attribute on the span; last write wins. Ignored after `end()`.
+
+Returns the span, so calls chain. Prefer primitive values: strings,
+booleans, integers and floats keep their type. Lists and mappings are
+sent as OTLP arrays and maps, but PostHog stores them as serialized
+strings. `None` removes the key; anything else is stringified.
+
+**Examples:**
+
+```python
+span.set_attribute("http.status_code", 200).set_attribute("cache.hit", True)
+```
+
+#### `posthog.tracing.span.Span.set_attributes`
+
+```python
+set_attributes(attributes: Mapping[str, Any]) -> Span
+```
+
+Set several attributes at once; last write wins per key. Ignored after `end()`.
+
+Returns the span, so calls chain. Same encoding as `set_attribute()`.
+
+**Examples:**
+
+```python
+span.set_attributes({"db.system": "postgresql", "db.rows": 12})
+```
+
+#### `posthog.tracing.span.Span.set_status`
+
+```python
+set_status(code: str, message: Optional[str] = None) -> Span
+```
+
+Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+
+Unset by default. Any other `code` is ignored. `ok` is final for the
+scoped form: an `Exception` raised inside `with span:` does not override
+it. Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span.set_status("error", "upstream timed out")
+```
+
+#### `posthog.tracing.span.Span.traceparent`
+
+```python
+traceparent() -> Optional[str]
+```
+
+The W3C `traceparent` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.tracestate`
+
+```python
+tracestate() -> Optional[str]
+```
+
+The W3C `tracestate` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.update_name`
+
+```python
+update_name(name: str) -> Span
+```
+
+Rename the span, for a name only known after it started. Ignored after `end()`.
+
+Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span = posthog.start_span("http.request")
+span.update_name(f"{request.method} {route.pattern}")
+```
+
+### `Emails`
+
+```python
+Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None, migrated_from: Optional[str] = None) -> None
+```
+
+Bases: `_EmailsBase`
+
+Sends transactional email from PostHog email templates or from content in your code.
+
+`host` is your PostHog app host. PostHog Cloud ingestion hosts map to the
+app host, so `us.i.posthog.com` sends to `us.posthog.com`. Any other
+host is used as given.
+
+Each send retries network errors, rate limits and an unavailable service up
+to `max_retries` times, with the same idempotency key. Set
+`max_retries=0` when a job runner already retries the send. `timeout`
+is in seconds, per request. Pass `session` to send through your own
+`requests.Session`, for example a test double. `migrated_from`, such
+as `"resend"`, tells PostHog which provider your sends came from.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`close` | Close the HTTP connections this client opened. A `session` you passed in stays open.
+`get` | Read what happened to an email that `send` queued.
+`send` | Queue one email, from a template in PostHog or from content in your code.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disabled` |  | 
+`host` |  | 
+`max_retries` |  | 
+`migrated_from` |  | 
+`secret_key` |  | 
+`timeout` |  | 
+
+#### `posthog.emails.Emails.close`
+
+```python
+close() -> None
+```
+
+Close the HTTP connections this client opened. A `session` you passed in stays open.
+
+#### `posthog.emails.Emails.disabled`
+
+```python
+disabled = disabled
+```
+
+#### `posthog.emails.Emails.get`
+
+```python
+get(message_id: Union[str, UUID]) -> EmailStatus
+```
+
+Read what happened to an email that `send` queued.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`message_id` | `Union[str, UUID]` | The `id` of the `SendEmailResult` that `send` returned. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`EmailStatus` | The email's latest status, for 30 days after the send.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not answer with a status. `code` is `not_found` for an unknown ID, an email older than 30 days, or for a few seconds after the send.
+`ValueError` | `message_id` is not a message ID.
+
+**Examples:**
+
+```python
+result = emails.send(to="user@example.com", template_id="...")
+status = emails.get(result.id)
+if status.status == "bounced":
+    print(status.reason)
+```
+
+#### `posthog.emails.Emails.host`
+
+```python
+host = determine_app_host(host)
+```
+
+#### `posthog.emails.Emails.max_retries`
+
+```python
+max_retries = max_retries
+```
+
+#### `posthog.emails.Emails.migrated_from`
+
+```python
+migrated_from = migrated_from
+```
+
+#### `posthog.emails.Emails.secret_key`
+
+```python
+secret_key = secret_key.strip() if isinstance(secret_key, str) else None
+```
+
+#### `posthog.emails.Emails.send`
+
+```python
+send(**kwargs: Any) -> SendEmailResult
+```
+
+Queue one email, from a template in PostHog or from content in your code.
+
+Pass exactly one form. The template form names a template made in
+PostHog with `template_id`. The code form names the email with
+`template_key` and passes `subject` and `html`, `text` or both:
+see `CodeEmailArgs`.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` |  | One recipient email address. | 
+`template_id` |  | The UUID of a template made transactional in PostHog. | 
+`template_data` |  | Values for the template's `{{ variables.* }}` placeholders. Values are encoded the way capture encodes properties. | 
+`distinct_id` |  | The recipient's distinct ID in your product. The email's events go to this person. Without it, they go to a person whose distinct ID is the email address. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. A send with a key that PostHog has already accepted queues nothing and returns the first send's result. Without it, the client makes a key that covers its own retries. Pass a key derived from what the email is for, such as `welcome:user_123`, to cover retries outside this call, too. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`SendEmailResult` | The queued email. A result means PostHog queued the email, not that it was delivered.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not queue the email, or the client could not tell whether it did.
+`(TypeError, ValueError)` | An argument has the wrong type or format.
+
+**Examples:**
+
+```python
+emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+    idempotency_key="welcome:user_123",
+)
+emails.send(
+    to="user@example.com",
+    template_key="password-reset",
+    subject="Reset your password",
+    html=rendered_html,
+    distinct_id="user_123",
+)
+```
+
+#### `posthog.emails.Emails.timeout`
+
+```python
+timeout = timeout
+```
+
+### `EmailError`
+
+```python
+EmailError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None) -> None
+```
+
+Bases: `Exception`
+
+PostHog did not queue the email, or the client could not tell whether it did.
+
+Branch on `code`, PostHog's stable error code, or on `name`, a coarse
+category of the failure. The message never contains the secret key or the
+request body.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`name` |  | A coarse category of the failure.
+`code` |  | PostHog's stable error code.
+`message` |  | What went wrong. It never contains the secret key or the request body.
+`status_code` |  | The HTTP status of the response, or `None` when none arrived.
+`why` |  | PostHog's explanation of the failure, when it gave one.
+`fix` |  | What to change to fix it, when PostHog said.
+`docs_url` |  | A docs page about the error, when PostHog gave one.
+`field` |  | The request field the error is about, when there is one.
+`retry_after` |  | Seconds to wait before retrying, when PostHog said.
+
+#### `posthog.emails.EmailError.code`
+
+```python
+code = code
+```
+
+#### `posthog.emails.EmailError.docs_url`
+
+```python
+docs_url = docs_url
+```
+
+#### `posthog.emails.EmailError.field`
+
+```python
+field = field
+```
+
+#### `posthog.emails.EmailError.fix`
+
+```python
+fix = fix
+```
+
+#### `posthog.emails.EmailError.message`
+
+```python
+message = message
+```
+
+#### `posthog.emails.EmailError.name`
+
+```python
+name = name
+```
+
+#### `posthog.emails.EmailError.retry_after`
+
+```python
+retry_after = retry_after
+```
+
+#### `posthog.emails.EmailError.status_code`
+
+```python
+status_code = status_code
+```
+
+#### `posthog.emails.EmailError.why`
+
+```python
+why = why
+```
+
+### `SendEmailResult`
+
+```python
+SendEmailResult(id: str, replayed: bool = False, warnings: tuple[EmailWarning, ...] = ()) -> None
+```
+
+The queued email. `id` is its message ID.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`id` | `str` | The email's message ID.
+`replayed` | `bool` | `True` when the response says PostHog replayed an earlier send for the same `idempotency_key` instead of sending again.
+`warnings` | `tuple[EmailWarning, ...]` | Warnings PostHog returned about the request.
+
+#### `posthog.emails.SendEmailResult.id`
+
+```python
+id: str
+```
+
+#### `posthog.emails.SendEmailResult.replayed`
+
+```python
+replayed: bool = False
+```
+
+#### `posthog.emails.SendEmailResult.warnings`
+
+```python
+warnings: tuple[EmailWarning, ...] = ()
+```
+
+### `OptionalSetArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the set method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the user to set properties on. If not set, the context distinct_id is used, if available, otherwise this function does nothing. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to set on the person | 
+`timestamp` |  | When the properties were set (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this operation. If not provided, one is generated. This UUID is returned, so you can correlate it with actions in your app. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this operation. Defaults to False. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalSetArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalSetArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalSetArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalSetArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalSetArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
+
+### `CodeEmailArgs`
+
+Bases: `_RecipientArgs`
+
+A send of email content that your code rendered for one recipient, named by a key.
+
+The content goes out as is. To send a React email, render it to HTML in
+your app first.
+
+An optional field passed as `None` counts as left out.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` |  | One recipient email address. | 
+`template_key` |  | Names the email, so its metrics, logs and status group under it. Letters, digits, `-` and `_`, at most 400. | 
+`subject` |  | The subject line. | 
+`html` |  | The HTML body. Give `html`, `text` or both. | 
+`text` |  | The plain-text body. Without it, PostHog derives it from `html`. HTML with no text in it, such as a single image, goes out without a plain-text part. | 
+`from_` |  | A verified sender, such as `"Acme <hello@example.com>"`. | 
+`reply_to` |  | One address or a list of addresses. An empty list sends no reply-to. | 
+`capture_engagement` |  | Capture the email's opens and clicks as events of the recipient. Defaults to `True`. A project whose admin turned engagement capture off captures nothing, whatever the send asks. A template made in PostHog follows the project's setting, so the template form doesn't take it. | 
+`distinct_id` |  | The recipient's distinct ID in your product. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. Template sends and code sends share one set of keys: a key already used for another email, or for a `template_id` send, raises `idempotency_key_reused`. A retry with the same key returns the first send's result, also when its workflow was paused since. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_engagement` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[str]]` | 
+`from_` | `NotRequired[Optional[str]]` | 
+`html` | `NotRequired[Optional[str]]` | 
+`idempotency_key` | `NotRequired[Optional[str]]` | 
+`max_retries` | `NotRequired[Optional[int]]` | 
+`reply_to` | `NotRequired[Optional[Union[str, Sequence[str]]]]` | 
+`subject` | `str` | 
+`template_key` | `str` | 
+`text` | `NotRequired[Optional[str]]` | 
+`to` | `str` | 
+
+#### `posthog.emails.CodeEmailArgs.capture_engagement`
+
+```python
+capture_engagement: NotRequired[Optional[bool]]
+```
+
+#### `posthog.emails.CodeEmailArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.from_`
+
+```python
+from_: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.html`
+
+```python
+html: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.idempotency_key`
+
+```python
+idempotency_key: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.max_retries`
+
+```python
+max_retries: NotRequired[Optional[int]]
+```
+
+#### `posthog.emails.CodeEmailArgs.reply_to`
+
+```python
+reply_to: NotRequired[Optional[Union[str, Sequence[str]]]]
+```
+
+#### `posthog.emails.CodeEmailArgs.subject`
+
+```python
+subject: str
+```
+
+#### `posthog.emails.CodeEmailArgs.template_key`
+
+```python
+template_key: str
+```
+
+#### `posthog.emails.CodeEmailArgs.text`
+
+```python
+text: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.to`
+
+```python
+to: str
+```
diff --git a/references/posthog-python-reference.md b/references/posthog-python-reference.md
new file mode 100644
index 000000000..8011d5817
--- /dev/null
+++ b/references/posthog-python-reference.md
@@ -0,0 +1,4100 @@
+---
+title: "PostHog Python SDK"
+sidebar: Docs
+showTitle: true
+contentMaxWidthClass: max-w-full
+platformLogo: python
+tableOfContents:
+  - value: "Getting started"
+    url: getting-started
+    depth: 0
+  - value: "Setup"
+    url: setup
+    depth: 0
+  - value: "Capture"
+    url: capture
+    depth: 0
+  - value: "Identify"
+    url: identify
+    depth: 0
+  - value: "Traces"
+    url: traces
+    depth: 0
+  - value: "Alias"
+    url: alias
+    depth: 0
+  - value: "Capture AI"
+    url: capture-ai
+    depth: 0
+  - value: "Capture exception"
+    url: capture-exception
+    depth: 0
+  - value: "Emails"
+    url: emails
+    depth: 0
+  - value: "Flush"
+    url: flush
+    depth: 0
+  - value: "Get feature flag"
+    url: get-feature-flag
+    depth: 0
+  - value: "Get feature flag payload"
+    url: get-feature-flag-payload
+    depth: 0
+  - value: "Get feature flag result"
+    url: get-feature-flag-result
+    depth: 0
+  - value: "Get feature flags"
+    url: get-feature-flags
+    depth: 0
+  - value: "Get feature flags and payloads"
+    url: get-feature-flags-and-payloads
+    depth: 0
+  - value: "Evaluate flags"
+    url: evaluate-flags
+    depth: 0
+  - value: "Group identify"
+    url: group-identify
+    depth: 0
+  - value: "Is feature enabled"
+    url: is-feature-enabled
+    depth: 0
+  - value: "Shutdown"
+    url: shutdown
+    depth: 0
+  - value: "Flag definition loader"
+    url: flag-definition-loader
+    depth: 0
+  - value: "SDK utils"
+    url: sdk-utils
+    depth: 0
+  - value: "AsyncClient"
+    url: asyncclient
+    depth: 0
+  - value: "Module functions"
+    url: module-functions
+    depth: 0
+  - value: "Types"
+    url: types
+    depth: 0
+---
+
+## Getting started
+
+
+The Python SDK captures events, evaluates feature flags and reports errors from Python 3.10 or later.
+
+To send your first event, install the package, create a client, capture an event, and shut the client down, as the steps below show.
+
+### Install
+
+```bash
+pip install posthog
+```
+
+### Initialize
+
+Create one client for your app with your project token and host. Your project token and host are in your [project settings](https://app.posthog.com/project/settings). Keep the token in an environment variable rather than in code.
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("<ph_project_token>", host="<ph_client_api_host>")
+```
+
+### Capture an event
+
+```python
+posthog.capture("user_signed_up", distinct_id="user_123", properties={"plan": "free"})
+```
+
+`capture` queues the event and returns right away. A background thread sends it.
+
+### Shut down
+
+Call `shutdown()` before your process exits, so queued events are sent.
+
+```python
+posthog.shutdown()
+```
+
+In an asyncio app, use `AsyncPosthog` as an async context manager instead. See [AsyncClient](#asyncclient).
+
+## Setup
+
+### `Client(...)`
+
+```python
+Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None)
+```
+
+Initialize a new PostHog client instance.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`project_api_key` | `str` | PostHog project API key/token. | *required*
+`host` |  | PostHog host. Defaults to the US ingestion endpoint when not set. App hosts such as `https://us.posthog.com` are mapped to the corresponding ingestion host. | `None`
+`debug` |  | Enable verbose SDK logging and re-raise errors from public API methods. | `False`
+`max_queue_size` |  | Maximum number of events buffered before upload. | `10000`
+`send` |  | If False, queueing succeeds but events are not sent. | `True`
+`on_error` |  | Optional callback invoked by background consumers when an upload fails. Keep it short and non-blocking. Calling lifecycle methods directly is safe and deferred, but do not start another thread or task that calls `flush()`, `join()`, or `shutdown()` and then wait for it from the callback. | `None`
+`flush_at` |  | Number of queued events that triggers a batch upload. | `100`
+`flush_interval` |  | Maximum seconds a background consumer waits before flushing a partial batch. | `5.0`
+`gzip` |  | Whether to gzip event upload payloads. | `False`
+`max_retries` |  | Number of upload retries. Values below 0 are treated as 0. | `3`
+`sync_mode` |  | If True, send each event synchronously instead of using background worker threads. This blocks the calling thread; in asyncio applications such as FastAPI, use `AsyncPosthog` instead. | `False`
+`timeout` | `float` | HTTP request timeout in seconds for event uploads. | `15`
+`thread` |  | Number of background consumer threads. | `1`
+`poll_interval` |  | Seconds between local feature flag definition refreshes. | `30`
+`secret_key` |  | A Personal API Key or Project Secret API Key, used to authenticate local feature flag evaluation, remote config payloads, and decrypted flag payloads. For example, `posthog.Client(project_api_key, secret_key="phx_...")`. | `None`
+`personal_api_key` |  | Deprecated alias for `secret_key`. Still honored for backwards compatibility; prefer `secret_key`, which also accepts a Project Secret API Key. | `None`
+`disabled` |  | If True, disable captures and API requests. Useful in tests. | `False`
+`disable_geoip` |  | Whether to disable server-side GeoIP enrichment. Defaults to True. | `True`
+`is_server` |  | Whether events are emitted from a server-side runtime. Defaults to True; set to False when using the SDK as a client/CLI so the device OS is attributed to the person normally. | `True`
+`historical_migration` |  | Mark events as historical migration imports. | `False`
+`feature_flags_request_timeout_seconds` | `float` | Timeout in seconds for feature flag and remote config requests. | `3`
+`feature_flags_request_max_retries` |  | Number of retries for feature flag requests after network, transport, or timeout failures. Defaults to 1. Set to 0 to disable retries. | `1`
+`app_host` | `Optional[str]` | Your PostHog app host, such as `https://posthog.example.com`. `emails` sends there. Needed only when `host` is not PostHog Cloud, for example a reverse proxy, which must not receive the secret key. | `None`
+`email_request_timeout_seconds` | `float` | Timeout in seconds for each email send request. Defaults to 15. | `15`
+`email_request_max_retries` | `int` | Number of retries for an email send after a network error, a rate limit, or an unavailable service. Defaults to 2. Set to 0 when a job runner already retries the send. | `2`
+`migrated_from` | `Optional[str]` | The email provider you moved from, such as `"resend"`. `emails` sends it with every request. | `None`
+`super_properties` |  | Properties merged into every captured event. | `None`
+`enable_exception_autocapture` |  | Automatically capture uncaught exceptions. | `False`
+`log_captured_exceptions` |  | Also log exceptions captured by error tracking. | `False`
+`project_root` |  | Root path used to determine in-app stack frames for captured exceptions. Defaults to the current working directory. | `None`
+`privacy_mode` |  | For AI observability, capture usage metadata without prompt inputs or outputs. | `False`
+`enable_full_ai_capture` |  | Route PostHog AI wrapper events through the dedicated AI capture endpoint and capture full AI content: skips string truncation and passes media (base64/data URIs) through unredacted. `privacy_mode` always wins. Defaults to False. | `False`
+`before_send` |  | Optional callback that can modify or drop events before upload. Return `None` to drop an event. | `None`
+`flag_fallback_cache_url` |  | Optional feature flag fallback cache URL, such as `memory://local/?ttl=300&size=10000` or a Redis URL. | `None`
+`enable_local_evaluation` |  | Whether to poll feature flag definitions for local evaluation when a personal API key is configured. | `True`
+`flag_definition_cache_provider` | `Optional[FlagDefinitionCacheProvider]` | Optional external cache provider for sharing feature flag definitions across workers. | `None`
+`capture_exception_code_variables` |  | Capture local variable values on exception stack frames. | `False`
+`capture_trace_context` |  | When OpenTelemetry is installed and a valid span is active at capture time, add its trace and span IDs as `$trace_id` and `$span_id` properties to events captured with `capture()` and `capture_ai()`, so they can be correlated with backend traces. Explicit `$trace_id`/`$span_id` values passed in `properties` win. Exception events (`capture_exception`) always attach these IDs regardless of this setting. Defaults to False. | `False`
+`traces` | `Optional[dict]` | Config dict for distributed tracing: `service_name`, `service_version`, `environment`, `resource_attributes`, `flush_interval` (5 s), `max_queue_size` (2048), `max_export_batch_size` (512), `max_live_spans` (10000), `max_span_age` (3600 s), `max_attributes_per_span` (128), `max_events_per_span` (128), `max_attribute_value_length` (8192). `before_span_send` is a callable, or a list run in order, that receives each finished span as a dict (`trace_id`, `span_id` and `parent_span_id` are read-only) and returns it, edited, or `None` to drop it; a hook that raises drops the span. Tracing is off until this is provided. Spans export on a background timer even with `sync_mode`; serverless handlers should call `flush()` before returning. Defaults to None. | `None`
+`code_variables_mask_patterns` |  | Variable-name patterns to mask when capturing code variables. | `None`
+`code_variables_ignore_patterns` |  | Variable-name patterns to omit when capturing code variables. | `None`
+`code_variables_mask_url_credentials` |  | Scrub credentials embedded in URLs/DSNs (e.g. `user:pass@host`) from captured code variables, regardless of the surrounding variable name. Defaults to True. | `None`
+`code_variables_detect_secrets` |  | Last-resort entropy-based detection that redacts high-entropy secret-looking values (API keys, tokens, strong passwords) sitting in innocuously-named variables, after the name and URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults to True. | `None`
+`in_app_modules` | `list[str] \| None` | Module/package prefixes treated as in-app frames in captured exceptions. | `None`
+`enable_exception_autocapture_rate_limiting` |  | Rate limit autocaptured exceptions client-side with a token bucket per exception type. Disabled by default. | `False`
+`exception_autocapture_bucket_size` |  | Maximum burst of autocaptured exceptions allowed per exception type (token bucket size, clamped to 0-100). | `DEFAULT_BUCKET_SIZE`
+`exception_autocapture_refill_rate` |  | Tokens restored per refill interval for each exception type's bucket. | `DEFAULT_REFILL_RATE`
+`exception_autocapture_refill_interval_seconds` |  | Seconds between token refills for autocaptured exception rate limiting. | `DEFAULT_REFILL_INTERVAL_SECONDS`
+`capture_mode` | `Optional[Union[CaptureMode, str]]` | Capture wire protocol to use. Defaults to `CaptureMode.V0` (legacy `/batch/`). Set `CaptureMode.V1` (or pass the string `"v1"`) to opt into `/i/v1/analytics/events`. When omitted, the `POSTHOG_CAPTURE_MODE` env var is consulted, then `V0`. | `None`
+`capture_compression` | `Optional[Union[CaptureCompression, str]]` | Request-body compression for capture-v1 uploads (ignored in V0, which uses `gzip`). `CaptureCompression.GZIP` or `DEFLATE` (or the strings `"gzip"`/`"deflate"`). When omitted, the `POSTHOG_CAPTURE_COMPRESSION` env var is consulted, then the legacy `gzip` flag, then no compression. | `None`
+
+**Examples:**
+
+```python
+from posthog import Posthog
+
+posthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')
+```
+
+## Capture
+
+### `Client.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to capture. | *required*
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to include with the event. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | A dictionary of group information. | 
+`flags` |  | A FeatureFlagEvaluations snapshot from evaluate_flags(). The exact values from the snapshot are attached with no extra /flags request. | 
+`send_feature_flags` |  | Deprecated. Prefer flags=... from evaluate_flags(). When truthy, evaluates flags during capture and attaches them to the event. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+# Anonymous event
+posthog.capture('some-anon-event')
+```
+```python
+# Context usage
+from posthog import identify_context, new_context
+with new_context():
+    identify_context('distinct_id_of_the_user')
+    posthog.capture('user_signed_up')
+    posthog.capture('user_logged_in')
+    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')
+```
+```python
+# Set event properties
+posthog.capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+```python
+# Page view event
+posthog.capture('$pageview', distinct_id="distinct_id_of_the_user", properties={'$current_url': 'https://example.com'})
+```
+
+## Identify
+
+### `Client.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+# Set with distinct id
+posthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+### `Client.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile only if they haven't been set before.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set once. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Traces
+
+### `Client.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on
+the way out); or call `end()` yourself for a span that cannot wrap a
+block. Spans started inside the block nest under it automatically.
+Always returns a usable handle, even when tracing is off, so calling
+code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. A forked child starts with no active span; pass the parent span to continue a trace across a fork. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+posthog = Posthog("<ph_project_api_key>", traces={"service_name": "checkout-api"})
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `Client.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes
+it active; a span started manually is not. Use it to propagate the
+trace to the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+## Alias
+
+### `Client.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+Create an alias between two distinct IDs.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The previous distinct ID. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`distinct_id` | `Optional[str]` | The new distinct ID to alias to. Falls back to the context distinct ID; the call is dropped with a warning if neither is available. | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+
+**Examples:**
+
+```python
+posthog.alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Capture AI
+
+### `Client.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size
+cap, batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`:
+the event UUID, or None when the event was not admitted (disabled
+client, or dropped by `before_send`). The event is queued on an
+isolated AI lane with its own consumer pool and a higher per-event
+size cap, posting to the dedicated AI ingestion endpoint. The payload
+is sent as given — no redaction or truncation is applied here.
+
+## Capture exception
+
+### `Client.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg], **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception for error tracking.
+
+When OpenTelemetry is installed and a valid span is active, its trace and
+span IDs are added as `$trace_id` and `$span_id` event properties.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. | *required*
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of additional properties. Overriding reserved exception properties is deprecated and will stop working in the next major version. | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. Attaches those exact flag values to the captured `$exception` event. | 
+`send_feature_flags` |  | Deprecated. Pass `flags` from `evaluate_flags()` instead. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+try:
+    # Some code that might fail
+    pass
+except Exception as e:
+    posthog.capture_exception(e, distinct_id='user_distinct_id', properties=additional_properties)
+```
+
+## Emails
+
+### `Client.emails`
+
+```python
+emails: Emails
+```
+
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
+scope. Sends go to `app_host`, or to the PostHog Cloud app host of
+`host`. `email_request_timeout_seconds` and `email_request_max_retries`
+configure each send. A disabled or shut-down client sends nothing. See
+`posthog.emails` for setup.
+
+**Examples:**
+
+```python
+client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+)
+```
+
+## Flush
+
+### `Client.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.
+
+For a client shared across requests or serverless invocations (including
+the module-level client), call `flush()` before a short-lived invocation
+returns. Use `shutdown()` instead only for final process cleanup or when
+disposing of a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after
+a timeout or span export failure, and failed events may be dropped by the
+consumers. Calls made directly from SDK callbacks such as `on_error` are
+deferred rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently. The span exporter waits up to this many seconds for an in-flight flush, then uses a fresh drain budget once it acquires the lock. If the lock wait times out, the in-flight flush is left to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. Each span request is bounded by the client's `timeout` in seconds, and the last request is not cut short. This is therefore not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the shared client open.
+posthog.flush(timeout_seconds=10)
+```
+
+## Get feature flag
+
+### `Client.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get multivariate feature flag value for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag payload
+
+### `Client.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, *, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload for a feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`match_value` | `Optional[FlagValue]` | The specific flag value to get payload for. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Deprecated. Use get_feature_flag() instead if you need events. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This method returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag result
+
+### `Client.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
+depending on whether local evaluation is enabled and the flag can be locally evaluated.
+This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+
+**Examples:**
+
+```python
+flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')
+if flag_result and flag_result.get_value() == 'variant-key':
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = flag_result.payload
+```
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagResult]` | Optional[FeatureFlagResult]: The feature flag result or None if disabled/not found.
+
+## Get feature flags
+
+### `Client.get_feature_variants`
+
+```python
+get_feature_variants(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Union[bool, str]]
+```
+
+Get feature flag variants for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+### `Client.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> Optional[dict[str, Union[bool, str]]]
+```
+
+Get all feature flags for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags('distinct_id_of_your_user')
+```
+
+## Get feature flags and payloads
+
+### `Client.get_feature_flags_and_payloads`
+
+```python
+get_feature_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get feature flags and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+result = posthog.get_feature_flags_and_payloads('<distinct_id>')
+```
+
+### `Client.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get all feature flags and their payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags_and_payloads('distinct_id_of_your_user')
+```
+
+## Evaluate flags
+
+### `Client.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[List[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+Local evaluation is transparent: when the poller resolves a flag, the
+snapshot's `$feature_flag_called` events are tagged `locally_evaluated=True`
+and reason `"Evaluated locally"`.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If True, never fall back to remote evaluation — flags that can't be evaluated locally are omitted from the snapshot and listed with a reason in its `unresolved_flags`. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[List[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is True. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagEvaluations` | A `FeatureFlagEvaluations` snapshot.
+
+**Examples:**
+
+```python
+flags = posthog.evaluate_flags(
+    "user_123",
+    person_properties={"plan": "enterprise"},
+)
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+## Group identify
+
+### `Client.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+Identify a group and set its properties.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | The type of group (e.g., 'company', 'team'). Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | The unique identifier for the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | A dictionary of properties to set on the group. | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[Union[str, UUID]]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user performing the action. | `None`
+
+**Examples:**
+
+```python
+posthog.group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Is feature enabled
+
+### `Client.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Check if a feature flag is enabled for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Shutdown
+
+### `Client.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.
+
+Failed or undrainable events may be dropped and reported through logging
+or `on_error`; returning does not guarantee server receipt. Lifecycle
+cleanup is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+posthog.join()
+```
+
+### `Client.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the client.
+
+Call this for final process cleanup or when disposing of a client that
+will not be reused. It closes capture lanes, stops background workers and
+the feature flag poller, and tears down integrations. Do not call it at the
+end of each request or serverless invocation when the client is shared;
+call `flush()` before returning instead. A shut-down client cannot be
+reused; create a new client if needed.
+
+Normally this method blocks until queued events have been attempted and
+cleanup finishes. Failed or undrainable events may be dropped and
+reported through logging or `on_error`; returning does not guarantee
+server receipt. Event draining has no timeout. Queued spans get one final
+flush with up to 30 seconds waiting for an in-flight flush, then a fresh
+30-second drain budget; the last HTTP request is not cut short. Any spans
+it cannot send are discarded with a warning, as are spans still open.
+Lifecycle cleanup is attempted once, and cleanup failures
+are logged without retry. When called directly from an SDK callback such as
+`on_error`, shutdown is deferred to avoid blocking the worker that
+invoked the callback. If the callback must coordinate a blocking
+shutdown, have it signal an
+application-owned thread and return before that thread calls shutdown.
+Do not wait inside the callback for another thread or task that calls a
+lifecycle method.
+
+**Examples:**
+
+```python
+posthog.shutdown()
+```
+
+## Flag definition loader
+
+### `Client.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flags for local evaluation.
+
+**Examples:**
+
+```python
+posthog.load_feature_flags()
+```
+
+### `Client.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Return feature flag definitions loaded for local evaluation.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The currently loaded feature flag definitions, or `None` before local evaluation has loaded definitions.
+
+## SDK utils
+
+### `Client.queue`
+
+```python
+queue: Queue
+```
+
+The analytics lane's queue (kept for backwards compatibility).
+
+### `Client.consumers`
+
+```python
+consumers: Optional[List[Consumer]]
+```
+
+Flat list of the lanes' consumers, analytics first (kept for backwards compatibility).
+
+### `Client.new_context`
+
+```python
+new_context(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+with client.new_context():
+    client.identify_context('<distinct_id>')
+    client.capture('event_name')
+```
+
+### `Client.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the wrapped function using this client.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+### `Client.tag`
+
+```python
+tag(name: str, value: Any) -> None
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key. | *required*
+`value` | `Any` | The tag value. | *required*
+
+### `Client.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context.
+
+### `Client.identify_context`
+
+```python
+identify_context(distinct_id: str) -> None
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_session`
+
+```python
+set_context_session(session_id: str) -> None
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str) -> None
+```
+
+Set the device ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children. | *required*
+
+### `Client.feature_flags`
+
+```python
+feature_flags
+```
+
+Get the local evaluation feature flags.
+
+### `Client.get_feature_payloads`
+
+```python
+get_feature_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Optional[str]]
+```
+
+Get feature flag payloads for a user, preserving valid serialized JSON.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+payloads = posthog.get_feature_payloads('<distinct_id>')
+```
+
+### `Client.get_flags_decision`
+
+```python
+get_flags_decision(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsResponse
+```
+
+Get feature flags decision.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+decision = posthog.get_flags_decision('user123')
+```
+
+### `Client.metrics`
+
+```python
+metrics: PostHogMetrics
+```
+
+The `posthog.metrics` API: a statsd-style pre-aggregating metrics client — alpha.
+
+Samples fold into per-series aggregates in memory and flush as one OTLP
+data point per series per window, so recording from hot paths is cheap.
+Configure via the `metrics` client option; pending metrics flush on
+`shutdown()`.
+
+**Examples:**
+
+```python
+client = Posthog("<ph_project_api_key>", metrics={"service_name": "billing-worker"})
+client.metrics.count("invoices.processed", 1, attributes={"plan": "pro"})
+client.metrics.gauge("queue.depth", 42)
+client.metrics.histogram("job.duration", 187, unit="ms")
+```
+
+### `Client.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The remote config feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag, or `None` if the client is disabled, no personal API key is configured, or the request fails. Encrypted payloads are decrypted by PostHog before being returned.
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires `secret_key` for authentication.
+
+</details>
+
+### `Client.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagEvaluationRuntime]` | The flag's evaluation runtime, or `None` when local evaluation has not loaded a definition for this key. A definition that carries no runtime reports `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+runtime = posthog.get_feature_flag_evaluation_runtime("my-flag")
+if runtime is FeatureFlagEvaluationRuntime.SERVER:
+    ...
+```
+
+### `Client.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime,
+so it is returned for `CLIENT` and for `SERVER`, and asking for
+`ALL` returns every loaded flag. Use this to decide which flags to hand
+to a browser when a backend serves flags to its own frontend.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`evaluation_runtime` | `Union[FeatureFlagEvaluationRuntime, str]` | The runtime to match, as a `FeatureFlagEvaluationRuntime` or its string value. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`list[str]` | The matching flag keys, in the order local evaluation loaded them. Empty when no definitions are loaded.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+client_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(
+    FeatureFlagEvaluationRuntime.CLIENT
+)
+```
+
+### `posthog.integrations.django.PosthogContextMiddleware`
+
+```python
+PosthogContextMiddleware(get_response)
+```
+
+Middleware to automatically track Django requests.
+
+This middleware wraps all calls with a posthog context. It attempts to extract the following from the request:
+- Session ID, (extracted from `X-POSTHOG-SESSION-ID`)
+- Distinct ID, (extracted from `X-POSTHOG-DISTINCT-ID`, falling back to the authenticated request user ID)
+- Authenticated user email as `email`
+- Request URL as `$current_url`
+- Request method as `$request_method`
+- Request path as `$request_path`
+- Forwarded IP address as `$ip`
+- User agent as `$user_agent`
+
+Configure the integration with these Django settings:
+- `POSTHOG_MW_CLIENT`: client used for automatic exception capture, or the global client.
+  This does not redirect events explicitly captured through other clients.
+- `POSTHOG_MW_CAPTURE_EXCEPTIONS`: `False` enables context enrichment only;
+  `True` enables automatic exception capture; `None` inherits the effective client's
+  `enable_exception_autocapture`. When omitted, the legacy default is `True`.
+- `POSTHOG_MW_REQUEST_FILTER`: a callback receiving the request. Returning `False`
+  disables both enrichment and automatic exception capture for that request.
+- `POSTHOG_MW_EXTRA_PROPERTIES`: a callback returning additional event properties.
+- `POSTHOG_MW_CAPTURE_TRACING_HEADERS`: read PostHog identity and session headers
+  as request-scoped analytics context (default: `True`). Explicit capture IDs and
+  event properties take precedence. These values are never authentication or
+  authorization. Authenticated Django user identity remains the fallback when no
+  usable header ID is available or header capture is disabled.
+- `POSTHOG_MW_TRUST_TRACING_HEADERS`: deprecated alias for
+  `POSTHOG_MW_CAPTURE_TRACING_HEADERS`; the capture-named setting takes precedence.
+- `POSTHOG_MW_PROPERTIES_MAP`: an optional callback transforming request properties.
+
+The old `POSTHOG_MW_EXTRA_TAGS` and `POSTHOG_MW_TAG_MAP` settings remain aliases;
+the property-named settings take precedence when both are configured.
+
+Request properties are included on all events captured within the active context,
+including when automatic exception capture is disabled.
+See the context documentation for more information. The extracted distinct ID and session ID,
+if found, are used to associate all events captured in the middleware context with the same distinct ID
+and session as currently active on the frontend. See the documentation for `set_context_session`
+and `identify_context` for more details.
+
+This middleware is hybrid-capable: it supports both WSGI (sync) and ASGI (async) Django applications. The middleware
+detects at initialization whether the next middleware in the chain is async or sync, and adapts its behavior accordingly.
+This ensures compatibility with both pure sync and pure async middleware chains, as well as mixed chains in ASGI mode.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`aextract_properties` | Async version of extract_properties for use in async request handling.
+`aextract_request_user` | Async version of extract_request_user for use in async request handling.
+`aextract_tags` | Compatibility alias for `aextract_properties`.
+`extract_properties` | Extract event properties and identity from a synchronous request.
+`extract_request_user` | Extract user ID and email from request in sync context.
+`extract_tags` | Compatibility alias for `extract_properties`.
+`process_exception` | Process exceptions from views and downstream middleware.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`async_capable` |  | 
+`capture_exceptions` | `Optional[bool]` | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`extra_tags` |  | Compatibility alias for `extra_properties`.
+`get_response` |  | 
+`properties_map` |  | 
+`request_filter` |  | 
+`sync_capable` |  | 
+`tag_map` |  | Compatibility alias for `properties_map`.
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+Initialize the middleware with Django's next handler.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`get_response` |  | The next middleware or view handler in Django's middleware chain. May be synchronous or asynchronous. | 
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_properties`
+
+```python
+async aextract_properties(request)
+```
+
+Async version of extract_properties for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_request_user`
+
+```python
+async aextract_request_user(request)
+```
+
+Async version of extract_request_user for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_tags`
+
+```python
+async aextract_tags(request)
+```
+
+Compatibility alias for `aextract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.async_capable`
+
+```python
+async_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_exceptions`
+
+```python
+capture_exceptions: Optional[bool] = capture_exceptions if (capture_exceptions is None or isinstance(capture_exceptions, bool)) else True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers, canonical_name='POSTHOG_MW_CAPTURE_TRACING_HEADERS', deprecated_name='POSTHOG_MW_TRUST_TRACING_HEADERS')
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.client`
+
+```python
+client = cast('Optional[Client]', settings.POSTHOG_MW_CLIENT)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_properties`
+
+```python
+extra_properties = cast('Callable[[HttpRequest], Dict[str, Any]]', extra_properties) if callable(extra_properties) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_tags`
+
+```python
+extra_tags
+```
+
+Compatibility alias for `extra_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_properties`
+
+```python
+extract_properties(request)
+```
+
+Extract event properties and identity from a synchronous request.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_request_user`
+
+```python
+extract_request_user(request)
+```
+
+Extract user ID and email from request in sync context.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_tags`
+
+```python
+extract_tags(request)
+```
+
+Compatibility alias for `extract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.get_response`
+
+```python
+get_response = get_response
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.process_exception`
+
+```python
+process_exception(request, exception)
+```
+
+Process exceptions from views and downstream middleware.
+
+Django calls this WHILE still inside the context created by __call__,
+so request tags have already been extracted and set. This method just
+needs to capture the exception directly.
+
+Django converts view exceptions into responses before they propagate through
+the middleware stack, so the context manager in __call__/__acall__ never sees them.
+
+Note: Django's process_exception is always synchronous, even for async views.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.properties_map`
+
+```python
+properties_map = cast('Callable[[Dict[str, Any]], Dict[str, Any]]', properties_map) if callable(properties_map) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.request_filter`
+
+```python
+request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.sync_capable`
+
+```python
+sync_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.tag_map`
+
+```python
+tag_map
+```
+
+Compatibility alias for `properties_map`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.flask.PosthogFlaskIntegration`
+
+```python
+PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog request context and exception tracking to a Flask app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `Optional[Flask]` | An optional Flask application. If omitted, call `init_app` later (the Flask application-factory pattern). | `None`
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions that reach Flask's unhandled exception machinery. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[Callable[[Request], bool]]` | Optional callback receiving Flask's request object. A false return value disables both context and exception capture for that request. | `None`
+`extra_properties` | `Optional[Callable[[Request], Mapping[str, Any]]]` | Optional callback returning additional event properties. This is useful for application-specific metadata such as an authenticated user's role. Values should not contain secrets or request bodies. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+The integration intentionally does not capture exceptions handled by an
+application error handler, expected HTTP exceptions, request or response
+bodies, query strings, cookies, authorization headers, or arbitrary headers.
+Call `capture_exception` explicitly from a custom error handler if a
+handled exception should be reported.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`init_app` | Register the integration with a Flask application once.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.init_app`
+
+```python
+init_app(app: Flask) -> None
+```
+
+Register the integration with a Flask application once.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.asgi.PosthogASGIMiddleware`
+
+```python
+PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: Optional[bool] = None, *, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog context and automatic exception capture to an ASGI app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `_ASGIApp` | The downstream ASGI application. | *required*
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions escaping the downstream app. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[_RequestFilter]` | Optional sync or async callback receiving the ASGI scope. Returning `False` bypasses all instrumentation for that scope. | `None`
+`extra_properties` | `Optional[_ExtraProperties]` | Optional sync or async callback receiving the ASGI scope and returning additional event properties. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`app` |  | 
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.app`
+
+```python
+app = app
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.celery.PosthogCeleryIntegration`
+
+```python
+PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
+```
+
+Celery integration that captures task lifecycle events and exceptions.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`client` | `Optional[Client]` | Optional `Client` instance. When provided, all events and exceptions are captured through this client rather than the global `posthog` module. Don't skip this if using a custom flag definition cache provider, and pass the custom `Client` instance here initialized with the custom provider so fork safety for that provider is handled correctly. | `None`
+`capture_exceptions` | `bool` | Whether to capture task exceptions via `capture_exception` (default `True`). | `True`
+`capture_task_lifecycle_events` | `bool` | Whether to emit lifecycle events of the task such as "started", "success", "failure" etc. (default `True`). | `True`
+`propagate_context` | `bool` | Whether to propagate PostHog context (distinct ID, session ID, tags) from the producer to the worker via task headers (default `True`). | `True`
+`task_filter` | `Optional[Callable[[Optional[str], dict[str, Any]], bool]]` | Optional callback `(task_name, task_properties) -> bool` expected to return `False` if a given task should not be tracked. | `None`
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`instrument` | Connect Celery signal handlers to capture task events and exceptions. Call this after initializing the PostHog client and this integration.
+`shutdown` | Disconnect all signal handlers registered by `instrument()`, flush all pending events and cleanly shutdown the integration.
+`uninstrument` | Disconnect Celery signal handlers and unregister exit cleanup.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_task_lifecycle_events` |  | 
+`client` |  | 
+`propagate_context` |  | 
+`task_filter` |  | 
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_task_lifecycle_events`
+
+```python
+capture_task_lifecycle_events = capture_task_lifecycle_events
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.instrument`
+
+```python
+instrument() -> None
+```
+
+Connect Celery signal handlers to capture task events and exceptions.
+Call this after initializing the PostHog client and this integration.
+
+If Celery runs on a single host, reinstrumenting in worker children is
+not strictly necessary because the PostHog client and this integration
+are fork-safe. If Celery workers run across multiple hosts, each worker
+process must initialize PostHog, this integration, and call
+`instrument()`. Celery provides `worker_process_init` signal to help
+with this.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.propagate_context`
+
+```python
+propagate_context = propagate_context
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Disconnect all signal handlers registered by `instrument()`, flush all pending events
+and cleanly shutdown the integration.
+
+`shutdown()` is also registered on `worker_process_shutdown` and `atexit` signals,
+but there is no guarantee those will always be called, so we strongly recommend calling
+it manually when the integration is no longer needed to avoid data loss.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.task_filter`
+
+```python
+task_filter = task_filter
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.uninstrument`
+
+```python
+uninstrument() -> None
+```
+
+Disconnect Celery signal handlers and unregister exit cleanup.
+
+Do not use directly, call `shutdown()` instead.
+
+### `posthog.request.set_socket_options`
+
+```python
+set_socket_options(socket_options: Optional[SocketOptions]) -> None
+```
+
+Configure socket options for all SDK HTTP connections.
+
+Call this during initialization, before making API requests. Pass `None`
+to reset to the default socket behavior.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`socket_options` | `Optional[SocketOptions]` | A list of `(level, option, value)` tuples accepted by urllib3/`socket.setsockopt()`, or `None` to reset defaults. | *required*
+
+<details class="example" open markdown="1">
+<summary>Example</summary>
+
+from posthog import set_socket_options
+set_socket_options([(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)])
+
+</details>
+
+### `posthog.request.enable_keep_alive`
+
+```python
+enable_keep_alive() -> None
+```
+
+Enable TCP keepalive for SDK HTTP connections.
+
+This helps prevent idle pooled connections from being dropped by network
+infrastructure. Call during initialization, before making API requests.
+
+### `posthog.request.disable_connection_reuse`
+
+```python
+disable_connection_reuse() -> None
+```
+
+Disable HTTP connection reuse for SDK requests.
+
+Each request will create a fresh connection. This can avoid issues with
+environments that terminate pooled connections, but adds per-request
+overhead. Call during initialization, before making API requests.
+
+## AsyncClient
+
+Needs the `async` extra, `posthog[async]`.
+
+### `AsyncClient(...)`
+
+```python
+AsyncClient(project_api_key: str, host: Optional[str] = None, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, gzip: bool = False, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_mode: Optional[Union[CaptureMode, str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None) -> None
+```
+
+### `AsyncClient.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Queue an event without blocking for network delivery.
+
+### `AsyncClient.capture_immediate`
+
+```python
+async capture_immediate(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture one event and wait until its delivery attempt completes.
+
+### `AsyncClient.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+### `AsyncClient.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception. This method never raises, including in debug mode.
+
+### `AsyncClient.emails`
+
+```python
+emails: AsyncEmails
+```
+
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
+scope, and `posthog[async]`. Sends go to `app_host`, or to the PostHog
+Cloud app host of `host`. `email_request_timeout_seconds` and
+`email_request_max_retries` configure each send. A disabled or shut-down
+client sends nothing. See `posthog.emails` for setup.
+
+**Examples:**
+
+```python
+await client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    distinct_id="user_123",
+)
+```
+
+### `AsyncClient.flush`
+
+```python
+async flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+### `AsyncClient.evaluate_flags`
+
+```python
+async evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate flags remotely without blocking the event loop.
+
+The returned snapshot has synchronous in-memory accessors. Pass it to
+`capture(flags=...)` to attach the exact values used for branching.
+This client does not evaluate flags locally, so the snapshot's
+`unresolved_flags` is always empty.
+
+### `AsyncClient.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+### `AsyncClient.shutdown`
+
+```python
+async shutdown() -> None
+```
+
+### `AsyncClient.join`
+
+```python
+async join() -> None
+```
+
+### `AsyncClient.get_remote_config_payload`
+
+```python
+async get_remote_config_payload(key: str) -> Optional[Any]
+```
+
+Fetch and decrypt a remote-config payload without blocking the loop.
+
+## Module functions
+
+### `posthog.new_context`
+
+```python
+new_context(fresh: bool = False, capture_exceptions: Optional[bool] = None, client: Optional[Client] = None)
+```
+
+Create a new context scope that will be active for the duration of the with block.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` | `bool` | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting. | `None`
+`client` | `Optional[Client]` | Optional Posthog client instance to use for this context (default: None) | `None`
+
+**Examples:**
+
+```python
+from posthog import new_context, tag, capture
+with new_context():
+    tag("request_id", "123")
+    capture("event_name", properties={"property": "value"})
+```
+
+### `posthog.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the function.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+from posthog import scoped, tag, capture
+@scoped()
+def process_payment(payment_id):
+    tag("payment_id", payment_id)
+    capture("payment_started")
+```
+
+### `posthog.set_context_session`
+
+```python
+set_context_session(session_id: str)
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_session
+set_context_session("session_123")
+```
+
+### `posthog.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str)
+```
+
+Set the device ID for the current context, associating all feature flag requests
+in this or child contexts with the given device ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_device_id
+set_context_device_id("device_123")
+```
+
+### `posthog.identify_context`
+
+```python
+identify_context(distinct_id: str)
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import identify_context
+identify_context("user_123")
+```
+
+### `posthog.set_capture_exception_code_variables_context`
+
+```python
+set_capture_exception_code_variables_context(enabled: bool)
+```
+
+Override code-variable capture for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`enabled` | `bool` | Whether exceptions captured in this context should include local variable values from stack frames. | *required*
+
+### `posthog.set_code_variables_mask_patterns_context`
+
+```python
+set_code_variables_mask_patterns_context(mask_patterns: list[str])
+```
+
+Override code-variable mask patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`mask_patterns` | `list[str]` | Variable-name patterns whose values should be replaced with `***` when code variables are captured. | *required*
+
+### `posthog.set_code_variables_ignore_patterns_context`
+
+```python
+set_code_variables_ignore_patterns_context(ignore_patterns: list[str])
+```
+
+Override code-variable ignore patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`ignore_patterns` | `list[str]` | Variable-name patterns that should be omitted entirely when code variables are captured. | *required*
+
+### `posthog.set_code_variables_mask_url_credentials_context`
+
+```python
+set_code_variables_mask_url_credentials_context(enabled: bool)
+```
+
+Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from
+captured code variables for the current context.
+
+### `posthog.set_code_variables_detect_secrets_context`
+
+```python
+set_code_variables_detect_secrets_context(enabled: bool)
+```
+
+Whether to apply entropy-based secret detection as a last-resort redaction of
+high-entropy values (API keys, tokens, strong passwords) in captured code
+variables for the current context.
+
+### `posthog.tag`
+
+```python
+tag(name: str, value: Any)
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key | *required*
+`value` | `Any` | The tag value | *required*
+
+**Examples:**
+
+```python
+from posthog import tag
+tag("user_id", "123")
+```
+
+### `posthog.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context
+
+### `posthog.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture anything a user does within your system.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to specify the event | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional arguments including: distinct_id: Unique identifier for the user properties: Dict of event properties timestamp: When the event occurred. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this event. If omitted, one is generated     and returned. If provided, it must be a valid UUID string or     uuid.UUID instance; invalid values are ignored and replaced with     a newly generated UUID. groups: Dict of group types and IDs flags: A FeatureFlagEvaluations snapshot from evaluate_flags(). The     exact values from the snapshot are attached with no extra /flags     request. send_feature_flags: Deprecated. Prefer flags=... from     evaluate_flags(). When truthy, evaluates flags during capture and     attaches them to the event. disable_geoip: Whether to disable GeoIP lookup | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.
+
+</details>
+
+**Examples:**
+
+```python
+# Context and capture usage
+from posthog import new_context, identify_context, tag, capture
+# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)
+with new_context():
+    # Associate this context with some user, by distinct_id
+    identify_context('some user')
+
+    # Capture an event, associated with the context-level distinct ID ('some user')
+    capture('movie started')
+
+    # Capture an event associated with some other user (overriding the context-level distinct ID)
+    capture('movie joined', distinct_id='some-other-user')
+
+    # Capture an event with some properties
+    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})
+
+    # Capture an event with some properties
+    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})
+    # Capture an event with some associated group
+    capture('purchase', groups={'company': 'id:5'})
+
+    # Adding a tag to the current context will cause it to appear on all subsequent events
+    tag('some-tag', 'some-value')
+
+    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict
+```
+```python
+# Set event properties
+from posthog import capture
+capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+
+### `posthog.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size cap,
+batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`: the
+event UUID, or None when the event was not admitted (disabled client, or
+dropped by `before_send`). The event is delivered on an isolated queue
+with its own consumer pool and a higher per-event size cap, posting to
+the dedicated AI ingestion endpoint. The payload is sent as given — no
+redaction or truncation is applied here.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name, normally one of the `$ai_*` event names. | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Same optional arguments as `capture()`. | `{}`
+
+**Examples:**
+
+```python
+from posthog import capture_ai
+
+uuid = capture_ai(
+    "$ai_generation",
+    distinct_id="user_123",
+    properties={"$ai_model": "gpt-5"},
+)
+```
+
+### `posthog.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).
+
+</details>
+
+**Examples:**
+
+```python
+# Set person properties
+from posthog import set
+set(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})
+```
+
+### `posthog.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record, only if they do not yet exist.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set only once. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.
+
+</details>
+
+**Examples:**
+
+```python
+# Set property once
+from posthog import set_once
+set_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})
+
+```
+
+### `posthog.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None) -> Optional[str]
+```
+
+Set properties on a group.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | Type of your group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | Unique identifier of the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | Properties to set on the group | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`distinct_id` | `Optional[ID_TYPES]` | Optional distinct ID of the user performing the action | `None`
+
+**Examples:**
+
+```python
+# Group identify
+from posthog import group_identify
+group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+### `posthog.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: str, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None) -> Optional[str]
+```
+
+Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The unique ID of the user before | *required*
+`distinct_id` | `str` | The current unique id | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like "Which marketing channels leads to users churning after a month?" or "What do users do on our website before signing up?". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+</details>
+
+**Examples:**
+
+```python
+# Alias user
+from posthog import alias
+alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+### `posthog.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture exceptions that happen in your code.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. If not provided, the current exception is captured via `sys.exc_info()` | `None`
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional capture arguments including distinct_id, properties, timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip. Overriding reserved exception properties through `properties` is deprecated and will stop working in the next major version. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the "traceback"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError("Some Error"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.
+
+</details>
+
+**Examples:**
+
+```python
+# Capture exception
+from posthog import capture_exception
+try:
+    risky_operation()
+except Exception as e:
+    capture_exception(e)
+```
+
+### `posthog.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Use feature flags to enable or disable features for users.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.
+
+</details>
+
+**Examples:**
+
+```python
+# Boolean feature flag
+from posthog import feature_enabled, get_feature_flag_payload
+is_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get feature flag variant for users. Used with experiments.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping from group type to group key | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties in format { group_type_name: { group_properties } } | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+`groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5", you would pass groups={"organization": "5"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count, you'll send these as: group_properties={"organization": {"name": "PostHog", "employees": 11}}.
+
+</details>
+
+**Examples:**
+
+```python
+# Multivariate feature flag
+from posthog import get_feature_flag, get_feature_flag_payload
+enabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key':
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> Optional[dict[str, FlagValue]]
+```
+
+Get all flags for a given user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate (evaluates all if None) | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.
+
+</details>
+
+**Examples:**
+
+```python
+# All flags for user
+from posthog import get_all_flags
+get_all_flags('distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload.
+
+This method evaluates a feature flag and returns a FeatureFlagResult object containing:
+- enabled: Whether the flag is enabled
+- variant: The variant value if the flag has variants
+- payload: The payload associated with the flag (automatically deserialized from JSON)
+- key: The flag key
+- reason: Why the flag was enabled/disabled
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+Example:
+```python
+result = posthog.get_feature_flag_result('beta-feature', 'distinct_id')
+if result and result.enabled:
+    # Use the variant and payload
+    print(f"Variant: {result.variant}")
+    print(f"Payload: {result.payload}")
+```
+
+### `posthog.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload associated with a feature flag value.
+
+Deprecated for new code. Prefer `evaluate_flags()` and
+`flags.get_flag_payload(key)` so flag evaluation happens once per request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`match_value` | `Optional[FlagValue]` | Optional flag value to use when selecting a payload. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This function returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+### `posthog.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The key of the feature flag | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag. If payload is encrypted, the return value will be decrypted
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires secret_key to be set for authentication
+
+</details>
+
+### `posthog.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> FlagsAndPayloads
+```
+
+Get all feature flag values and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate. Evaluates all flags when omitted. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FlagsAndPayloads` | A dict with `featureFlags` and `featureFlagPayloads` entries.
+
+### `posthog.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture()` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If `True`, never fall back to remote evaluation and omit flags that cannot be evaluated locally. The snapshot's `unresolved_flags` lists them with a reason. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[list[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is `True`. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Examples:**
+
+```python
+from posthog import evaluate_flags, capture
+flags = evaluate_flags("user_123", person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+### `posthog.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Returns loaded feature flags.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import feature_flag_definitions
+definitions = feature_flag_definitions()
+```
+
+### `posthog.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Reads the `evaluation_runtime` each flag definition carries, so no extra
+request is made. Returns `None` when local evaluation has not loaded a
+definition for this key. A definition that carries no runtime reports
+`FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime
+runtime = get_feature_flag_evaluation_runtime("my-flag")
+```
+
+### `posthog.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so
+it is returned for `CLIENT` and for `SERVER`. Use this to decide which
+flags to hand to a browser when a backend serves flags to its own
+frontend.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime
+client_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)
+```
+
+### `posthog.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flag definitions from PostHog.
+
+**Examples:**
+
+```python
+from posthog import load_feature_flags
+load_feature_flags()
+```
+
+### `posthog.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.
+
+Call `flush()` before a short-lived request or serverless invocation returns
+when using the shared module-level client. Use `shutdown()` only for final
+process cleanup or a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after a
+timeout or span export failure, and failed events may be dropped by consumers.
+Calls made directly from SDK callbacks such as `on_error` are deferred
+rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently, waiting up to this many seconds for an in-flight flush before starting a fresh drain budget. A lock wait timeout leaves the in-flight flush to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. The last span request is not cut short and is bounded by the client's `timeout` in seconds, so this is not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+import posthog
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the global client open.
+posthog.flush(timeout_seconds=10)
+```
+
+### `posthog.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.
+
+Failed or undrainable events may be dropped and reported through logging or
+`on_error`; returning does not guarantee server receipt. Lifecycle cleanup
+is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+from posthog import join
+join()
+```
+
+### `posthog.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime.datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on the
+way out); or call `end()` yourself for a span that cannot wrap a block.
+Spans started inside the block nest under it automatically. Always returns
+a usable handle, even when tracing is off, so calling code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+import posthog
+posthog.traces = {"service_name": "checkout-api"}
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `posthog.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes it
+active; a span started manually is not. Use it to propagate the trace to
+the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+### `posthog.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the global client.
+
+Call this for final process cleanup, not at the end of each request or
+serverless invocation that shares the module-level client. Use `flush()`
+before returning from those invocations instead. Shutdown closes capture
+lanes, stops background workers and the feature flag poller, and tears down
+integrations. The global client is not recreated automatically after shutdown.
+
+This normally blocks until queued events have been attempted and cleanup
+finishes. Failed or undrainable events may be dropped and reported through
+logging or `on_error`; returning does not guarantee server receipt. Event
+draining has no timeout. Queued spans get a final flush with up to 30 seconds
+waiting for an in-flight flush, then a fresh 30-second drain budget; the last
+HTTP request is not cut short. Unsent queued spans and still-open spans are
+discarded with a warning.
+Lifecycle cleanup is attempted once, and cleanup failures are logged without
+retry. Calls made directly from SDK callbacks such as `on_error` are deferred
+to avoid deadlocking the worker. If blocking completion is required, signal an application-owned
+thread, return from the callback, and call `shutdown()` from that thread.
+Do not wait inside a callback for another thread or task calling a lifecycle
+method.
+
+**Examples:**
+
+```python
+from posthog import shutdown
+shutdown()
+```
+
+### `posthog.setup`
+
+```python
+setup() -> Client
+```
+
+Create or return the global PostHog client configured by module settings.
+
+Most applications should either instantiate `Posthog` directly or set
+`posthog.api_key`/other module settings before calling top-level helpers.
+`setup()` is called automatically by global APIs such as `capture()`.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Client` | The global `Client` instance. If both `api_key` and `project_api_key` are missing or blank, the client is disabled and module-level calls become no-ops.
+
+## Types
+
+### `OptionalCaptureArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the capture method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the person associated with this event. If not set, the context distinct_id is used, if available, otherwise a UUID is generated, and the event is marked as personless. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to track with the event | 
+`timestamp` |  | When the event occurred (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this specific event. If not provided, one is generated. The event UUID is returned, so you can correlate it with actions in your app (like showing users an error ID if you capture an exception). If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | Group identifiers to associate with this event (format: {group_type: group_key}) | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. The exact flag values from the snapshot are attached to the event with no additional network call — prefer this over `send_feature_flags`. | 
+`send_feature_flags` |  | Deprecated — prefer `flags` with a `FeatureFlagEvaluations` snapshot. Whether to include currently active feature flags in the event properties. Can be a boolean or a SendFeatureFlagsOptions object. Defaults to False. Fires a hidden `/flags` request on capture and may return different values than the ones the code branched on. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this event. Defaults to False. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`flags` | `NotRequired[Optional[FeatureFlagEvaluations]]` | 
+`groups` | `NotRequired[Optional[Dict[str, str]]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`send_feature_flags` | `NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalCaptureArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.flags`
+
+```python
+flags: NotRequired[Optional[FeatureFlagEvaluations]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.groups`
+
+```python
+groups: NotRequired[Optional[Dict[str, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.send_feature_flags`
+
+```python
+send_feature_flags: NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
+
+### `FeatureFlagEvaluations`
+
+```python
+FeatureFlagEvaluations(host: _FeatureFlagEvaluationsHost, distinct_id: str, flags: Dict[str, _EvaluatedFlagRecord], groups: Optional[Mapping[str, Union[str, int]]] = None, disable_geoip: Optional[bool] = None, request_id: Optional[str] = None, evaluated_at: Optional[int] = None, errors_while_computing: bool = False, quota_limited: bool = False, minimal_flag_called_events: bool = False, accessed: Optional[Set[str]] = None, unresolved_flags: Optional[Mapping[str, UnresolvedFlagReason]] = None) -> None
+```
+
+A point-in-time snapshot of feature flag evaluations for a single distinct_id.
+
+Returned by `Client.evaluate_flags` — branch on `is_enabled` /
+`get_flag` and pass the same object to `Client.capture` via the
+`flags` option so the captured event carries the exact flag values the code
+branched on.
+
+```python
+flags = posthog.evaluate_flags(distinct_id, person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id=distinct_id, flags=flags)
+```
+
+To narrow the set of flags that get attached to a captured event, use the in-memory
+helpers `only` and `only_accessed`. To narrow the set of flags requested
+from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`get_flag` | Return the flag value. Fires `$feature_flag_called` on first access.
+`get_flag_payload` | Return the payload associated with a flag.
+`is_enabled` | Return whether the flag is enabled. Fires `$feature_flag_called` on the first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+`only` | Return a filtered copy containing only flags with the given keys. Keys that are not present in the evaluation are dropped and logged as a warning.
+`only_accessed` | Return a filtered copy containing only flags accessed via `is_enabled` or `get_flag` before this call.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`keys` | `List[str]` | Return the flag keys that are part of this evaluation.
+`unresolved_flags` | `Mapping[str, UnresolvedFlagReason]` | Return a read-only mapping of flag key to the reason local evaluation left it without a value.
+
+Internal — instances are created by the SDK via `Client.evaluate_flags()`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag`
+
+```python
+get_flag(key: str, *, send_feature_flag_events: bool = True) -> Optional[FlagValue]
+```
+
+Return the flag value. Fires `$feature_flag_called` on first access.
+
+Returns the variant string for multivariate flags, `True` for enabled flags
+without a variant, `False` for disabled flags, and `None` for flags that
+were not returned by the evaluation.
+
+Pass `send_feature_flag_events=False` to skip the event for this read, as
+with `is_enabled`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag_payload`
+
+```python
+get_flag_payload(key: str) -> Optional[Any]
+```
+
+Return the payload associated with a flag.
+
+Does not count as an access for `only_accessed` and does not fire any event.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.is_enabled`
+
+```python
+is_enabled(key: str, default_value: bool = False, *, send_feature_flag_events: bool = True) -> bool
+```
+
+Return whether the flag is enabled. Fires `$feature_flag_called` on the
+first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`default_value` | `bool` | Returned when the flag has no value in this evaluation — the key was not part of the evaluated set, or the evaluation itself came back empty (failed `/flags` request, quota limit, or no resolvable `distinct_id`). Defaults to `False`. | `False`
+`send_feature_flag_events` | `bool` | Whether this read sends `$feature_flag_called`. When `False`, no event is sent and the dedupe cache is left alone, but the key still counts as accessed for `only_accessed`. | `True`
+
+A flag that has a value always wins over `default_value`, including a
+disabled flag, which returns `False` even when `default_value=True`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.keys`
+
+```python
+keys: List[str]
+```
+
+Return the flag keys that are part of this evaluation.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only`
+
+```python
+only(keys: List[str]) -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags with the given keys. Keys that
+are not present in the evaluation are dropped and logged as a warning.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only_accessed`
+
+```python
+only_accessed() -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags accessed via `is_enabled`
+or `get_flag` before this call.
+
+Order-dependent: if nothing has been accessed yet, the returned snapshot is
+empty. The method honors its name — pre-access if you want a populated result.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.unresolved_flags`
+
+```python
+unresolved_flags: Mapping[str, UnresolvedFlagReason]
+```
+
+Return a read-only mapping of flag key to the reason local evaluation
+left it without a value.
+
+A flag is listed when it has a loaded local definition, was in the requested
+scope, was inconclusive locally, and no remote value filled the gap. Listed
+flags are not part of `keys`, and reading one reports the
+`local_evaluation_inconclusive` error instead of `flag_missing`. Reading
+this mapping does not count as an access and does not fire any event.
+Snapshots returned by `only` and `only_accessed`, and by
+`AsyncClient.evaluate_flags()`, which evaluates only remotely, carry no
+entries.
+
+### `FeatureFlagResult`
+
+```python
+FeatureFlagResult(key: str, enabled: bool, variant: Optional[str], payload: Optional[Any], reason: Optional[str]) -> None
+```
+
+The result of calling a feature flag which includes the flag result, variant, and payload.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | The unique identifier of the feature flag.
+`enabled` | `bool` | Whether the feature flag is enabled for the current context.
+`variant` | `Optional[str]` | The variant value if the flag is enabled and has variants, None otherwise.
+`payload` | `Optional[Any]` | Additional data associated with the feature flag, if any.
+`reason` | `Optional[str]` | A description of why the flag was enabled or disabled, if available.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_flag_details` | Create a FeatureFlagResult from a FeatureFlag object.
+`from_value_and_payload` | Creates a FeatureFlagResult from a flag value and payload.
+`get_value` | Returns the value of the flag. This is the variant if it exists, otherwise the enabled value. This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+#### `posthog.types.FeatureFlagResult.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlagResult.from_flag_details`
+
+```python
+from_flag_details(details: Union[FeatureFlag, None], override_match_value: Optional[FlagValue] = None) -> FeatureFlagResult | None
+```
+
+Create a FeatureFlagResult from a FeatureFlag object.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`details` | `Union[FeatureFlag, None]` | The FeatureFlag object to convert. | *required*
+`override_match_value` | `Optional[FlagValue]` | If provided, this value will be used to populate the enabled and variant fields instead of the values from the FeatureFlag. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagResult \| None` | FeatureFlagResult | None: A new FeatureFlagResult instance, or None if details is None.
+
+#### `posthog.types.FeatureFlagResult.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: Union[FlagValue, None], payload: Any) -> Union[FeatureFlagResult, None]
+```
+
+Creates a FeatureFlagResult from a flag value and payload.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The unique identifier of the feature flag. | *required*
+`value` | `Union[FlagValue, None]` | The value of the flag (string variant or boolean). | *required*
+`payload` | `Any` | Additional data associated with the feature flag. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Union[FeatureFlagResult, None]` | Union[FeatureFlagResult, None]: A new FeatureFlagResult instance, or None if value is None.
+
+#### `posthog.types.FeatureFlagResult.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Returns the value of the flag. This is the variant if it exists, otherwise the enabled value.
+This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+**Returns:**
+
+Name | Type | Description
+---- | ---- | -----------
+`FlagValue` | `FlagValue` | Either a string variant or boolean value representing the flag's state.
+
+#### `posthog.types.FeatureFlagResult.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlagResult.payload`
+
+```python
+payload: Optional[Any]
+```
+
+#### `posthog.types.FeatureFlagResult.reason`
+
+```python
+reason: Optional[str]
+```
+
+#### `posthog.types.FeatureFlagResult.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FeatureFlag`
+
+```python
+FeatureFlag(key: str, enabled: bool, variant: Optional[str], reason: Optional[FlagReason], metadata: Union[FlagMetadata, LegacyFlagMetadata]) -> None
+```
+
+Detailed feature flag evaluation returned by the flags API.
+
+`enabled`, `variant` and `metadata.payload` are the value rendered the way
+responses before `/flags?v=4` carried it, which the legacy getters return.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | Feature flag key.
+`enabled` | `bool` | Whether the flag is enabled for the evaluated user or group.
+`variant` | `Optional[str]` | Variant key for multivariate flags, otherwise `None`.
+`reason` | `Optional[FlagReason]` | Optional reason metadata explaining the result.
+`metadata` | `Union[FlagMetadata, LegacyFlagMetadata]` | Payload and other metadata returned by the API.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_json` | Parse one flag record of a `/flags` response.
+`from_value_and_payload` | Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+`get_value` | Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlag.from_json`
+
+```python
+from_json(resp: Any) -> FeatureFlag
+```
+
+Parse one flag record of a `/flags` response.
+
+A record with a `value` member is a `/flags?v=4` record. A record
+without one comes from an older server: its value is `variant`, or
+`enabled` when there is no variant, and its config version is `1`.
+
+#### `posthog.types.FeatureFlag.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: FlagValue, payload: Any) -> FeatureFlag
+```
+
+Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+
+#### `posthog.types.FeatureFlag.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlag.metadata`
+
+```python
+metadata: Union[FlagMetadata, LegacyFlagMetadata]
+```
+
+#### `posthog.types.FeatureFlag.reason`
+
+```python
+reason: Optional[FlagReason]
+```
+
+#### `posthog.types.FeatureFlag.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FlagsAndPayloads`
+
+Bases: `TypedDict`
+
+Feature flag values and payloads keyed by feature flag key.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`featureFlags` | `Optional[dict[str, FlagValue]]` | Each flag's value, keyed by flag key.
+`featureFlagPayloads` | `Optional[dict[str, Any]]` | Each flag's payload, keyed by flag key.
+
+#### `posthog.types.FlagsAndPayloads.featureFlagPayloads`
+
+```python
+featureFlagPayloads: Optional[dict[str, Any]]
+```
+
+#### `posthog.types.FlagsAndPayloads.featureFlags`
+
+```python
+featureFlags: Optional[dict[str, FlagValue]]
+```
+
+### `UnresolvedFlagReason`
+
+Bases: `str`, `Enum`
+
+Why local evaluation left a flag without a value.
+
+Reported by `FeatureFlagEvaluations.unresolved_flags`. Inheriting from
+`str` keeps the members directly comparable to their string values. When more
+than one cause applies, the first reason in the order below is reported.
+
+<details class="values" open markdown="1">
+<summary>Values</summary>
+
+EXPERIENCE_CONTINUITY: The flag has experience continuity enabled, which
+    local evaluation never resolves. Change the flag to fix it.
+UNSUPPORTED_DEFINITION: The flag uses something the local evaluator does not
+    support, such as a static cohort, an unknown operator, a malformed value,
+    a dependency with no loaded definition or a circular dependency. Change
+    the flag or upgrade the SDK to fix it.
+UNRESOLVED_DEPENDENCY: A flag this flag depends on has a loaded definition
+    but was unresolved.
+MISSING_CONTEXT: The call did not pass a property, group property or device
+    id the flag needs, or passed it in an unusable form. Pass it to fix it.
+
+</details>
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`EXPERIENCE_CONTINUITY` |  | 
+`MISSING_CONTEXT` |  | 
+`UNRESOLVED_DEPENDENCY` |  | 
+`UNSUPPORTED_DEFINITION` |  | 
+
+#### `posthog.types.UnresolvedFlagReason.EXPERIENCE_CONTINUITY`
+
+```python
+EXPERIENCE_CONTINUITY = 'experience_continuity'
+```
+
+#### `posthog.types.UnresolvedFlagReason.MISSING_CONTEXT`
+
+```python
+MISSING_CONTEXT = 'missing_context'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNRESOLVED_DEPENDENCY`
+
+```python
+UNRESOLVED_DEPENDENCY = 'unresolved_dependency'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNSUPPORTED_DEFINITION`
+
+```python
+UNSUPPORTED_DEFINITION = 'unsupported_definition'
+```
+
+### `InconclusiveMatchError`
+
+```python
+InconclusiveMatchError(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when local evaluation can't determine a flag's value. `reason` says
+why, as reported by `FeatureFlagEvaluations.unresolved_flags`.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why local evaluation couldn't resolve the flag.
+
+#### `posthog.feature_flags.InconclusiveMatchError.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `RequiresServerEvaluation`
+
+```python
+RequiresServerEvaluation(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when feature flag evaluation requires server-side data that is not
+available locally (e.g., static cohorts).
+
+This error should propagate immediately to trigger API fallback, unlike
+InconclusiveMatchError which allows trying other conditions.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why the flag needs server-side evaluation.
+
+#### `posthog.feature_flags.RequiresServerEvaluation.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `Span`
+
+A handle to a span.
+
+Every method is safe to call on any handle, including after `end()` and
+on the inert handles returned when tracing is off, so calling code never
+branches on whether tracing is running. Entering a handle (`with span:`)
+makes it the active span for the block and ends it on exit, recording an
+`Exception` raised inside it. A `BaseException` that is not an
+`Exception` (`GeneratorExit`, `CancelledError`, `KeyboardInterrupt`)
+still ends the span but is not recorded as a failure.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`add_event` | Add a timestamped event to the span. Ignored after `end()`.
+`end` | End the span and queue it for export. Idempotent.
+`record_exception` | Record an exception as an `exception` event and mark the span `error`.
+`set_attribute` | Set one attribute on the span; last write wins. Ignored after `end()`.
+`set_attributes` | Set several attributes at once; last write wins per key. Ignored after `end()`.
+`set_status` | Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+`traceparent` | The W3C `traceparent` header value to propagate, or `None`.
+`tracestate` | The W3C `tracestate` header value to propagate, or `None`.
+`update_name` | Rename the span, for a name only known after it started. Ignored after `end()`.
+
+#### `posthog.tracing.span.Span.add_event`
+
+```python
+add_event(name: str, attributes: Optional[Mapping[str, Any]] = None, timestamp: Union[datetime, float, None] = None) -> Span
+```
+
+Add a timestamped event to the span. Ignored after `end()`.
+
+`timestamp` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`. Returns the span, so calls
+chain.
+
+**Examples:**
+
+```python
+span.add_event("cache.miss", {"key": "user:42"})
+```
+
+#### `posthog.tracing.span.Span.end`
+
+```python
+end(end_time: Union[datetime, float, None] = None) -> None
+```
+
+End the span and queue it for export. Idempotent.
+
+`end_time` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`, and is never earlier than
+the start. Later calls, and later mutations, no-op. `with span:`
+ends the span on exit, so call this only for spans started manually.
+
+**Examples:**
+
+```python
+span = posthog.start_span("job")
+try:
+    run_job()
+finally:
+    span.end()
+```
+
+#### `posthog.tracing.span.Span.record_exception`
+
+```python
+record_exception(exception: BaseException) -> Span
+```
+
+Record an exception as an `exception` event and mark the span `error`.
+
+Ignored after `end()`. The event carries `exception.type`,
+`exception.message` and, for a raised exception,
+`exception.stacktrace` (its last `max_attribute_value_length`
+characters, so a chained traceback keeps the outermost exception and
+may lose its cause). Returns the span, so calls chain. Inside
+`with span:` a raised `Exception` is recorded automatically, so
+this is for exceptions that are caught and handled.
+
+**Examples:**
+
+```python
+try:
+    charge(card)
+except PaymentError as e:
+    span.record_exception(e)
+```
+
+#### `posthog.tracing.span.Span.set_attribute`
+
+```python
+set_attribute(key: str, value: Any) -> Span
+```
+
+Set one attribute on the span; last write wins. Ignored after `end()`.
+
+Returns the span, so calls chain. Prefer primitive values: strings,
+booleans, integers and floats keep their type. Lists and mappings are
+sent as OTLP arrays and maps, but PostHog stores them as serialized
+strings. `None` removes the key; anything else is stringified.
+
+**Examples:**
+
+```python
+span.set_attribute("http.status_code", 200).set_attribute("cache.hit", True)
+```
+
+#### `posthog.tracing.span.Span.set_attributes`
+
+```python
+set_attributes(attributes: Mapping[str, Any]) -> Span
+```
+
+Set several attributes at once; last write wins per key. Ignored after `end()`.
+
+Returns the span, so calls chain. Same encoding as `set_attribute()`.
+
+**Examples:**
+
+```python
+span.set_attributes({"db.system": "postgresql", "db.rows": 12})
+```
+
+#### `posthog.tracing.span.Span.set_status`
+
+```python
+set_status(code: str, message: Optional[str] = None) -> Span
+```
+
+Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+
+Unset by default. Any other `code` is ignored. `ok` is final for the
+scoped form: an `Exception` raised inside `with span:` does not override
+it. Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span.set_status("error", "upstream timed out")
+```
+
+#### `posthog.tracing.span.Span.traceparent`
+
+```python
+traceparent() -> Optional[str]
+```
+
+The W3C `traceparent` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.tracestate`
+
+```python
+tracestate() -> Optional[str]
+```
+
+The W3C `tracestate` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.update_name`
+
+```python
+update_name(name: str) -> Span
+```
+
+Rename the span, for a name only known after it started. Ignored after `end()`.
+
+Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span = posthog.start_span("http.request")
+span.update_name(f"{request.method} {route.pattern}")
+```
+
+### `Emails`
+
+```python
+Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None, migrated_from: Optional[str] = None) -> None
+```
+
+Bases: `_EmailsBase`
+
+Sends transactional email from PostHog email templates or from content in your code.
+
+`host` is your PostHog app host. PostHog Cloud ingestion hosts map to the
+app host, so `us.i.posthog.com` sends to `us.posthog.com`. Any other
+host is used as given.
+
+Each send retries network errors, rate limits and an unavailable service up
+to `max_retries` times, with the same idempotency key. Set
+`max_retries=0` when a job runner already retries the send. `timeout`
+is in seconds, per request. Pass `session` to send through your own
+`requests.Session`, for example a test double. `migrated_from`, such
+as `"resend"`, tells PostHog which provider your sends came from.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`close` | Close the HTTP connections this client opened. A `session` you passed in stays open.
+`get` | Read what happened to an email that `send` queued.
+`send` | Queue one email, from a template in PostHog or from content in your code.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disabled` |  | 
+`host` |  | 
+`max_retries` |  | 
+`migrated_from` |  | 
+`secret_key` |  | 
+`timeout` |  | 
+
+#### `posthog.emails.Emails.close`
+
+```python
+close() -> None
+```
+
+Close the HTTP connections this client opened. A `session` you passed in stays open.
+
+#### `posthog.emails.Emails.disabled`
+
+```python
+disabled = disabled
+```
+
+#### `posthog.emails.Emails.get`
+
+```python
+get(message_id: Union[str, UUID]) -> EmailStatus
+```
+
+Read what happened to an email that `send` queued.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`message_id` | `Union[str, UUID]` | The `id` of the `SendEmailResult` that `send` returned. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`EmailStatus` | The email's latest status, for 30 days after the send.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not answer with a status. `code` is `not_found` for an unknown ID, an email older than 30 days, or for a few seconds after the send.
+`ValueError` | `message_id` is not a message ID.
+
+**Examples:**
+
+```python
+result = emails.send(to="user@example.com", template_id="...")
+status = emails.get(result.id)
+if status.status == "bounced":
+    print(status.reason)
+```
+
+#### `posthog.emails.Emails.host`
+
+```python
+host = determine_app_host(host)
+```
+
+#### `posthog.emails.Emails.max_retries`
+
+```python
+max_retries = max_retries
+```
+
+#### `posthog.emails.Emails.migrated_from`
+
+```python
+migrated_from = migrated_from
+```
+
+#### `posthog.emails.Emails.secret_key`
+
+```python
+secret_key = secret_key.strip() if isinstance(secret_key, str) else None
+```
+
+#### `posthog.emails.Emails.send`
+
+```python
+send(**kwargs: Any) -> SendEmailResult
+```
+
+Queue one email, from a template in PostHog or from content in your code.
+
+Pass exactly one form. The template form names a template made in
+PostHog with `template_id`. The code form names the email with
+`template_key` and passes `subject` and `html`, `text` or both:
+see `CodeEmailArgs`.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` |  | One recipient email address. | 
+`template_id` |  | The UUID of a template made transactional in PostHog. | 
+`template_data` |  | Values for the template's `{{ variables.* }}` placeholders. Values are encoded the way capture encodes properties. | 
+`distinct_id` |  | The recipient's distinct ID in your product. The email's events go to this person. Without it, they go to a person whose distinct ID is the email address. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. A send with a key that PostHog has already accepted queues nothing and returns the first send's result. Without it, the client makes a key that covers its own retries. Pass a key derived from what the email is for, such as `welcome:user_123`, to cover retries outside this call, too. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`SendEmailResult` | The queued email. A result means PostHog queued the email, not that it was delivered.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not queue the email, or the client could not tell whether it did.
+`(TypeError, ValueError)` | An argument has the wrong type or format.
+
+**Examples:**
+
+```python
+emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+    idempotency_key="welcome:user_123",
+)
+emails.send(
+    to="user@example.com",
+    template_key="password-reset",
+    subject="Reset your password",
+    html=rendered_html,
+    distinct_id="user_123",
+)
+```
+
+#### `posthog.emails.Emails.timeout`
+
+```python
+timeout = timeout
+```
+
+### `EmailError`
+
+```python
+EmailError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None) -> None
+```
+
+Bases: `Exception`
+
+PostHog did not queue the email, or the client could not tell whether it did.
+
+Branch on `code`, PostHog's stable error code, or on `name`, a coarse
+category of the failure. The message never contains the secret key or the
+request body.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`name` |  | A coarse category of the failure.
+`code` |  | PostHog's stable error code.
+`message` |  | What went wrong. It never contains the secret key or the request body.
+`status_code` |  | The HTTP status of the response, or `None` when none arrived.
+`why` |  | PostHog's explanation of the failure, when it gave one.
+`fix` |  | What to change to fix it, when PostHog said.
+`docs_url` |  | A docs page about the error, when PostHog gave one.
+`field` |  | The request field the error is about, when there is one.
+`retry_after` |  | Seconds to wait before retrying, when PostHog said.
+
+#### `posthog.emails.EmailError.code`
+
+```python
+code = code
+```
+
+#### `posthog.emails.EmailError.docs_url`
+
+```python
+docs_url = docs_url
+```
+
+#### `posthog.emails.EmailError.field`
+
+```python
+field = field
+```
+
+#### `posthog.emails.EmailError.fix`
+
+```python
+fix = fix
+```
+
+#### `posthog.emails.EmailError.message`
+
+```python
+message = message
+```
+
+#### `posthog.emails.EmailError.name`
+
+```python
+name = name
+```
+
+#### `posthog.emails.EmailError.retry_after`
+
+```python
+retry_after = retry_after
+```
+
+#### `posthog.emails.EmailError.status_code`
+
+```python
+status_code = status_code
+```
+
+#### `posthog.emails.EmailError.why`
+
+```python
+why = why
+```
+
+### `SendEmailResult`
+
+```python
+SendEmailResult(id: str, replayed: bool = False, warnings: tuple[EmailWarning, ...] = ()) -> None
+```
+
+The queued email. `id` is its message ID.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`id` | `str` | The email's message ID.
+`replayed` | `bool` | `True` when the response says PostHog replayed an earlier send for the same `idempotency_key` instead of sending again.
+`warnings` | `tuple[EmailWarning, ...]` | Warnings PostHog returned about the request.
+
+#### `posthog.emails.SendEmailResult.id`
+
+```python
+id: str
+```
+
+#### `posthog.emails.SendEmailResult.replayed`
+
+```python
+replayed: bool = False
+```
+
+#### `posthog.emails.SendEmailResult.warnings`
+
+```python
+warnings: tuple[EmailWarning, ...] = ()
+```
+
+### `OptionalSetArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the set method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the user to set properties on. If not set, the context distinct_id is used, if available, otherwise this function does nothing. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to set on the person | 
+`timestamp` |  | When the properties were set (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this operation. If not provided, one is generated. This UUID is returned, so you can correlate it with actions in your app. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this operation. Defaults to False. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalSetArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalSetArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalSetArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalSetArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalSetArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
+
+### `CodeEmailArgs`
+
+Bases: `_RecipientArgs`
+
+A send of email content that your code rendered for one recipient, named by a key.
+
+The content goes out as is. To send a React email, render it to HTML in
+your app first.
+
+An optional field passed as `None` counts as left out.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` |  | One recipient email address. | 
+`template_key` |  | Names the email, so its metrics, logs and status group under it. Letters, digits, `-` and `_`, at most 400. | 
+`subject` |  | The subject line. | 
+`html` |  | The HTML body. Give `html`, `text` or both. | 
+`text` |  | The plain-text body. Without it, PostHog derives it from `html`. HTML with no text in it, such as a single image, goes out without a plain-text part. | 
+`from_` |  | A verified sender, such as `"Acme <hello@example.com>"`. | 
+`reply_to` |  | One address or a list of addresses. An empty list sends no reply-to. | 
+`capture_engagement` |  | Capture the email's opens and clicks as events of the recipient. Defaults to `True`. A project whose admin turned engagement capture off captures nothing, whatever the send asks. A template made in PostHog follows the project's setting, so the template form doesn't take it. | 
+`distinct_id` |  | The recipient's distinct ID in your product. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. Template sends and code sends share one set of keys: a key already used for another email, or for a `template_id` send, raises `idempotency_key_reused`. A retry with the same key returns the first send's result, also when its workflow was paused since. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_engagement` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[str]]` | 
+`from_` | `NotRequired[Optional[str]]` | 
+`html` | `NotRequired[Optional[str]]` | 
+`idempotency_key` | `NotRequired[Optional[str]]` | 
+`max_retries` | `NotRequired[Optional[int]]` | 
+`reply_to` | `NotRequired[Optional[Union[str, Sequence[str]]]]` | 
+`subject` | `str` | 
+`template_key` | `str` | 
+`text` | `NotRequired[Optional[str]]` | 
+`to` | `str` | 
+
+#### `posthog.emails.CodeEmailArgs.capture_engagement`
+
+```python
+capture_engagement: NotRequired[Optional[bool]]
+```
+
+#### `posthog.emails.CodeEmailArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.from_`
+
+```python
+from_: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.html`
+
+```python
+html: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.idempotency_key`
+
+```python
+idempotency_key: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.max_retries`
+
+```python
+max_retries: NotRequired[Optional[int]]
+```
+
+#### `posthog.emails.CodeEmailArgs.reply_to`
+
+```python
+reply_to: NotRequired[Optional[Union[str, Sequence[str]]]]
+```
+
+#### `posthog.emails.CodeEmailArgs.subject`
+
+```python
+subject: str
+```
+
+#### `posthog.emails.CodeEmailArgs.template_key`
+
+```python
+template_key: str
+```
+
+#### `posthog.emails.CodeEmailArgs.text`
+
+```python
+text: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.to`
+
+```python
+to: str
+```

From ec79737922ec6e72fc01ff153a75dcc650077793 Mon Sep 17 00:00:00 2001
From: "Vincent (Wen Yu) Ge" <29069505+gewenyu99@users.noreply.github.com>
Date: Tue, 10 Nov 2026 15:11:37 -0500
Subject: [PATCH 235/245] docs: generate the experimental 8 reference and
 migration page (#1184)

* docs: generate the experimental 8 reference and migration page

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the experimental 8 reference and migration page

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8 and migration pages

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8 and migration pages with griffe2md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8 and migration pages from v1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8 page from v1 with the capability map

The Category boxes are gone; nothing else changed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8.x reference without private parameters

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the 8.x reference with whole summaries and Returns

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: regenerate the Python 8 reference with the getting-started intro

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 references/posthog-python-8.md         | 4210 ++++++++++++++++++++++++
 references/posthog-python-migration.md |  269 ++
 2 files changed, 4479 insertions(+)
 create mode 100644 references/posthog-python-8.md
 create mode 100644 references/posthog-python-migration.md

diff --git a/references/posthog-python-8.md b/references/posthog-python-8.md
new file mode 100644
index 000000000..cdaf0c02e
--- /dev/null
+++ b/references/posthog-python-8.md
@@ -0,0 +1,4210 @@
+---
+title: "PostHog Python SDK 8.x (experimental)"
+sidebar: Docs
+showTitle: true
+contentMaxWidthClass: max-w-full
+platformLogo: python
+tableOfContents:
+  - value: "Getting started"
+    url: getting-started
+    depth: 0
+  - value: "Setup"
+    url: setup
+    depth: 0
+  - value: "Capture"
+    url: capture
+    depth: 0
+  - value: "Identify"
+    url: identify
+    depth: 0
+  - value: "Traces"
+    url: traces
+    depth: 0
+  - value: "Alias"
+    url: alias
+    depth: 0
+  - value: "Capture AI"
+    url: capture-ai
+    depth: 0
+  - value: "Capture exception"
+    url: capture-exception
+    depth: 0
+  - value: "Emails"
+    url: emails
+    depth: 0
+  - value: "Flush"
+    url: flush
+    depth: 0
+  - value: "Get feature flag"
+    url: get-feature-flag
+    depth: 0
+  - value: "Get feature flag payload"
+    url: get-feature-flag-payload
+    depth: 0
+  - value: "Get feature flag result"
+    url: get-feature-flag-result
+    depth: 0
+  - value: "Get feature flags"
+    url: get-feature-flags
+    depth: 0
+  - value: "Get feature flags and payloads"
+    url: get-feature-flags-and-payloads
+    depth: 0
+  - value: "Evaluate flags"
+    url: evaluate-flags
+    depth: 0
+  - value: "Group identify"
+    url: group-identify
+    depth: 0
+  - value: "Is feature enabled"
+    url: is-feature-enabled
+    depth: 0
+  - value: "Shutdown"
+    url: shutdown
+    depth: 0
+  - value: "Flag definition loader"
+    url: flag-definition-loader
+    depth: 0
+  - value: "SDK utils"
+    url: sdk-utils
+    depth: 0
+  - value: "AsyncClient"
+    url: asyncclient
+    depth: 0
+  - value: "Module functions"
+    url: module-functions
+    depth: 0
+  - value: "Types"
+    url: types
+    depth: 0
+---
+
+## Getting started
+
+
+The Python SDK captures events, evaluates feature flags and reports errors from Python 3.10 or later.
+
+To send your first event, install the package, create a client, capture an event, and shut the client down, as the steps below show.
+
+### Install
+
+```bash
+pip install posthog
+```
+
+### Initialize
+
+Create one client for your app with your project token and host. Your project token and host are in your [project settings](https://app.posthog.com/project/settings). Keep the token in an environment variable rather than in code.
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("<ph_project_token>", host="<ph_client_api_host>")
+```
+
+### Capture an event
+
+```python
+posthog.capture("user_signed_up", distinct_id="user_123", properties={"plan": "free"})
+```
+
+`capture` queues the event and returns right away. A background thread sends it.
+
+### Shut down
+
+Call `shutdown()` before your process exits, so queued events are sent.
+
+```python
+posthog.shutdown()
+```
+
+In an asyncio app, use `AsyncPosthog` as an async context manager instead. See [AsyncClient](#asyncclient).
+
+## Setup
+
+### `Client(...)`
+
+```python
+Client(project_api_key: str, host=None, *, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, super_options=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
+```
+
+Initialize a new PostHog client instance.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`project_api_key` | `str` | PostHog project API key/token. | *required*
+`host` |  | PostHog host. Defaults to the US ingestion endpoint when not set. App hosts such as `https://us.posthog.com` are mapped to the corresponding ingestion host. | `None`
+`debug` |  | Enable verbose SDK logging and re-raise errors from public API methods. | `False`
+`max_queue_size` |  | Maximum number of analytics events buffered before upload. AI events use `capture_ai_max_queue_size`. | `10000`
+`send` |  | If False, queueing succeeds but events are not sent. | `True`
+`on_error` |  | Optional callback `(error, batch)` invoked when an upload fails: by background consumers, or on the calling thread in `sync_mode`. Capture failures arrive as `CaptureError`. Without it, each failed batch logs one aggregate line. A capture that fails inside the callback logs that line instead of calling it again. Keep it short and non-blocking. Calling lifecycle methods directly is safe and deferred, but do not start another thread or task that calls `flush()`, `join()`, or `shutdown()` and then wait for it from the callback. | `None`
+`flush_at` |  | Number of queued events that triggers a batch upload. | `100`
+`flush_interval` |  | Maximum seconds a background consumer waits before flushing a partial batch. | `5.0`
+`max_retries` |  | Number of upload retries. Values below 0 are treated as 0. | `3`
+`sync_mode` |  | If True, send each event synchronously instead of using background worker threads. This blocks the calling thread; in asyncio applications such as FastAPI, use `AsyncPosthog` instead. | `False`
+`timeout` | `float` | HTTP request timeout in seconds for event uploads. | `15`
+`thread` |  | Number of background consumer threads. | `1`
+`poll_interval` |  | Seconds between local feature flag definition refreshes. | `30`
+`secret_key` |  | A Personal API Key or Project Secret API Key, used to authenticate local feature flag evaluation, remote config payloads, and decrypted flag payloads. For example, `posthog.Client(project_api_key, secret_key="phx_...")`. | `None`
+`personal_api_key` |  | Deprecated alias for `secret_key`. Still honored for backwards compatibility; prefer `secret_key`, which also accepts a Project Secret API Key. | `None`
+`disabled` |  | If True, disable captures and API requests. Useful in tests. | `False`
+`disable_geoip` |  | Whether to disable server-side GeoIP enrichment. Defaults to True. Events get `$geoip_disable` only when the event, context tags and `super_properties` leave it unset. | `True`
+`is_server` |  | Whether events are emitted from a server-side runtime. Defaults to True; set to False when using the SDK as a client/CLI so the device OS is attributed to the person normally. Events get `$is_server` only when the event, context tags and `super_properties` leave it unset. | `True`
+`historical_migration` |  | Mark events as historical migration imports. | `False`
+`feature_flags_request_timeout_seconds` | `float` | Timeout in seconds for feature flag and remote config requests. | `3`
+`feature_flags_request_max_retries` |  | Number of retries for feature flag requests after network, transport, or timeout failures. Defaults to 1. Set to 0 to disable retries. | `1`
+`app_host` | `Optional[str]` | Your PostHog app host, such as `https://posthog.example.com`. `emails` sends there. Needed only when `host` is not PostHog Cloud, for example a reverse proxy, which must not receive the secret key. | `None`
+`email_request_timeout_seconds` | `float` | Timeout in seconds for each email send request. Defaults to 15. | `15`
+`email_request_max_retries` | `int` | Number of retries for an email send after a network error, a rate limit, or an unavailable service. Defaults to 2. Set to 0 when a job runner already retries the send. | `2`
+`super_properties` |  | Properties for every captured event. They fill only keys the event leaves unset, before `before_send` runs. `$set`, `$set_once`, `$groups` and `$group_set` fill one level deep. An event's own properties and context tags override them, and `before_send` can change or remove them. | `None`
+`super_options` |  | Capture options for every captured event, such as `{"cookieless_mode": True}`. They fill only options the event leaves unset, before `before_send` runs. An event's own `options` and context options override them, and `before_send` can change them. They also win over an event's legacy property for the same key, such as `$cookieless_mode`, so pass per-event overrides of that key as `options`. | `None`
+`enable_exception_autocapture` |  | Automatically capture uncaught exceptions. | `False`
+`log_captured_exceptions` |  | Also log exceptions captured by error tracking. | `False`
+`project_root` |  | Root path used to determine in-app stack frames for captured exceptions. Defaults to the current working directory. | `None`
+`privacy_mode` |  | For AI observability, capture usage metadata without prompt inputs or outputs. | `False`
+`enable_full_ai_capture` |  | Capture full AI content in PostHog AI wrapper events: skips string truncation and passes media (base64/data URIs) through unredacted. `privacy_mode` always wins. Wrapper events use the AI capture endpoint whether or not this is set. Defaults to False. | `False`
+`before_send` |  | Optional callback that can modify or drop events before upload. Return `None` to drop an event. Context tags, context options, `super_properties`, `super_options` and the values the SDK adds, such as `$is_server`, `$geoip_disable` and `$os`, fill in before it runs, so it can change or remove them. | `None`
+`flag_fallback_cache_url` |  | Optional feature flag fallback cache URL, such as `memory://local/?ttl=300&size=10000` or a Redis URL. | `None`
+`enable_local_evaluation` |  | Whether to poll feature flag definitions for local evaluation when a personal API key is configured. | `True`
+`flag_definition_cache_provider` | `Optional[FlagDefinitionCacheProvider]` | Optional external cache provider for sharing feature flag definitions across workers. | `None`
+`capture_exception_code_variables` |  | Capture local variable values on exception stack frames. | `False`
+`capture_trace_context` |  | When OpenTelemetry is installed and a valid span is active at capture time, add its trace and span IDs as `$trace_id` and `$span_id` properties to events captured with `capture()` and `capture_ai()`, so they can be correlated with backend traces. They fill after context tags and `super_properties`, before `before_send`. A `$trace_id` or `$span_id` from the event, a context tag or `super_properties` stops the SDK adding either ID. Exception events (`capture_exception`) always attach these IDs regardless of this setting. Defaults to False. | `False`
+`traces` | `Optional[dict]` | Config dict for distributed tracing: `service_name`, `service_version`, `environment`, `resource_attributes`, `flush_interval` (5 s), `max_queue_size` (2048), `max_export_batch_size` (512), `max_live_spans` (10000), `max_span_age` (3600 s), `max_attributes_per_span` (128), `max_events_per_span` (128), `max_attribute_value_length` (8192). `before_span_send` is a callable, or a list run in order, that receives each finished span as a dict (`trace_id`, `span_id` and `parent_span_id` are read-only) and returns it, edited, or `None` to drop it; a hook that raises drops the span. Tracing is off until this is provided. Spans export on a background timer even with `sync_mode`; serverless handlers should call `flush()` before returning. Defaults to None. | `None`
+`code_variables_mask_patterns` |  | Variable-name patterns to mask when capturing code variables. | `None`
+`code_variables_ignore_patterns` |  | Variable-name patterns to omit when capturing code variables. | `None`
+`code_variables_mask_url_credentials` |  | Scrub credentials embedded in URLs/DSNs (e.g. `user:pass@host`) from captured code variables, regardless of the surrounding variable name. Defaults to True. | `None`
+`code_variables_detect_secrets` |  | Last-resort entropy-based detection that redacts high-entropy secret-looking values (API keys, tokens, strong passwords) sitting in innocuously-named variables, after the name and URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults to True. | `None`
+`in_app_modules` | `list[str] \| None` | Module/package prefixes treated as in-app frames in captured exceptions. | `None`
+`enable_exception_autocapture_rate_limiting` |  | Rate limit autocaptured exceptions client-side with a token bucket per exception type. Disabled by default. | `False`
+`exception_autocapture_bucket_size` |  | Maximum burst of autocaptured exceptions allowed per exception type (token bucket size, clamped to 0-100). | `DEFAULT_BUCKET_SIZE`
+`exception_autocapture_refill_rate` |  | Tokens restored per refill interval for each exception type's bucket. | `DEFAULT_REFILL_RATE`
+`exception_autocapture_refill_interval_seconds` |  | Seconds between token refills for autocaptured exception rate limiting. | `DEFAULT_REFILL_INTERVAL_SECONDS`
+`capture_compression` | `Optional[Union[CaptureCompression, str]]` | Request-body compression for `capture()` uploads. `CaptureCompression.GZIP` or `DEFLATE` (or the strings `"gzip"`/`"deflate"`). When omitted, the `POSTHOG_CAPTURE_COMPRESSION` env var is consulted, then no compression. | `None`
+`capture_ai_compression` | `Optional[Union[CaptureCompression, str]]` | Request-body compression for `capture_ai()` uploads, set independently of `capture_compression`. Defaults to no compression, and the env var does not apply. `CaptureCompression.ZSTD` suits large AI payloads. | `None`
+`capture_ai_max_queue_size` | `int` | Maximum number of AI events buffered before upload. Defaults to 1000, lower than `max_queue_size` because AI events are much larger. | `1000`
+`capture_ai_timeout` | `float` | Seconds allowed for one AI upload request. Defaults to 30, longer than `timeout` because AI batches are much larger. | `30`
+`capture_ai_max_event_bytes` | `int` | Largest serialized AI event the SDK sends; a larger one is dropped with an error log. Defaults to the AI endpoint's ceiling plus envelope headroom, and may only be lowered. | `AI_MAX_MSG_SIZE`
+
+**Examples:**
+
+```python
+from posthog import Posthog
+
+posthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')
+```
+
+## Capture
+
+### `Client.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to capture. | *required*
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to include with the event. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | A dictionary of group information. It merges into a `$groups` property and wins key by key. | 
+`flags` |  | A FeatureFlagEvaluations snapshot from evaluate_flags(). The exact values from the snapshot are attached with no extra /flags request. | 
+`send_feature_flags` |  | Deprecated. Prefer flags=... from evaluate_flags(). When truthy, evaluates flags during capture and attaches them to the event. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. It wins over a `$geoip_disable` in context tags or `super_properties`. A `$geoip_disable` property in this call's `properties` wins over it. | 
+`options` |  | Capture options for this event, such as `{"process_person_profile": False}`. Sent as given, for PostHog to validate. They override context options and `super_options`, which fill in before `before_send` runs. An option set at any layer wins over its legacy `$` property, such as `$process_person_profile`, set at any layer. A `None` option counts as unset. | 
+
+**Examples:**
+
+```python
+# Anonymous event
+posthog.capture('some-anon-event')
+```
+```python
+# Context usage
+from posthog import identify_context, new_context
+with new_context():
+    identify_context('distinct_id_of_the_user')
+    posthog.capture('user_signed_up')
+    posthog.capture('user_logged_in')
+    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')
+```
+```python
+# Set event properties
+posthog.capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+```python
+# Page view event
+posthog.capture('$pageview', distinct_id="distinct_id_of_the_user", properties={'$current_url': 'https://example.com'})
+```
+
+## Identify
+
+### `Client.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+# Set with distinct id
+posthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+### `Client.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a person profile only if they haven't been set before.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of properties to set once. | 
+`timestamp` |  | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Traces
+
+### `Client.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on
+the way out); or call `end()` yourself for a span that cannot wrap a
+block. Spans started inside the block nest under it automatically.
+Always returns a usable handle, even when tracing is off, so calling
+code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. A forked child starts with no active span; pass the parent span to continue a trace across a fork. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+posthog = Posthog("<ph_project_api_key>", traces={"service_name": "checkout-api"})
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `Client.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes
+it active; a span started manually is not. Use it to propagate the
+trace to the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+## Alias
+
+### `Client.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+Create an alias between two distinct IDs.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The previous distinct ID. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`distinct_id` | `Optional[str]` | The new distinct ID to alias to. Required - the call is dropped with a warning if it is missing or empty. The context distinct ID is never used here. | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+`options` | `Optional[Dict[str, Any]]` | Capture options for this event, sent as given. | `None`
+
+**Examples:**
+
+```python
+posthog.alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Capture AI
+
+### `Client.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size
+cap, batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`:
+the event UUID, or None when the event was not admitted (disabled
+client, or dropped by `before_send`). The event is queued on an
+isolated AI lane with its own consumer pool and a higher per-event
+size cap, posting to the dedicated AI ingestion endpoint. The payload
+is sent as given — no redaction or truncation is applied here.
+
+## Capture exception
+
+### `Client.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg], *, level: Optional[str] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception for error tracking.
+
+When OpenTelemetry is installed and a valid span is active, its trace and
+span IDs are added as `$trace_id` and `$span_id` event properties,
+unless the event, a context tag or `super_properties` sets either one.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. | *required*
+`level` | `Optional[str]` | The `$exception_level`, such as `"warning"` or `"fatal"`. Defaults to `"error"`. An unknown value counts as unset. | `None`
+`distinct_id` |  | The distinct ID of the user. | 
+`properties` |  | A dictionary of additional properties. Reserved exception properties, such as `$exception_list` and `$exception_level`, are ignored. | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. Attaches those exact flag values to the captured `$exception` event. | 
+`send_feature_flags` |  | Deprecated. Pass `flags` from `evaluate_flags()` instead. | 
+`disable_geoip` |  | Whether to disable GeoIP for this event. | 
+
+**Examples:**
+
+```python
+try:
+    # Some code that might fail
+    pass
+except Exception as e:
+    posthog.capture_exception(e, distinct_id='user_distinct_id', properties=additional_properties)
+```
+
+## Emails
+
+### `Client.emails`
+
+```python
+emails: Emails
+```
+
+Send transactional email from PostHog email templates, and read the
+status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `hog_flow:write`
+scope. Sends go to `app_host`, or to the PostHog Cloud app host of
+`host`. `email_request_timeout_seconds` and `email_request_max_retries`
+configure each send. A disabled or shut-down client sends nothing. See
+`posthog.emails` for setup.
+
+**Examples:**
+
+```python
+client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+)
+```
+
+## Flush
+
+### `Client.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.
+
+For a client shared across requests or serverless invocations (including
+the module-level client), call `flush()` before a short-lived invocation
+returns. Use `shutdown()` instead only for final process cleanup or when
+disposing of a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after
+a timeout or span export failure, and failed events may be dropped by the
+consumers. Calls made directly from SDK callbacks such as `on_error` are
+deferred rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently. The span exporter waits up to this many seconds for an in-flight flush, then uses a fresh drain budget once it acquires the lock. If the lock wait times out, the in-flight flush is left to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. Each span request is bounded by the client's `timeout` in seconds, and the last request is not cut short. This is therefore not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the shared client open.
+posthog.flush(timeout_seconds=10)
+```
+
+## Get feature flag
+
+### `Client.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get multivariate feature flag value for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag payload
+
+### `Client.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, *, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload for a feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`match_value` | `Optional[FlagValue]` | The specific flag value to get payload for. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Deprecated. Use get_feature_flag() instead if you need events. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This method returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Get feature flag result
+
+### `Client.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
+depending on whether local evaluation is enabled and the flag can be locally evaluated.
+This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+
+**Examples:**
+
+```python
+flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')
+if flag_result and flag_result.get_value() == 'variant-key':
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = flag_result.payload
+```
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagResult]` | Optional[FeatureFlagResult]: The feature flag result or None if disabled/not found.
+
+## Get feature flags
+
+### `Client.get_feature_variants`
+
+```python
+get_feature_variants(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Union[bool, str]]
+```
+
+Get feature flag variants for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+### `Client.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> Optional[dict[str, Union[bool, str]]]
+```
+
+Get all feature flags for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags('distinct_id_of_your_user')
+```
+
+## Get feature flags and payloads
+
+### `Client.get_feature_flags_and_payloads`
+
+```python
+get_feature_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get feature flags and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+result = posthog.get_feature_flags_and_payloads('<distinct_id>')
+```
+
+### `Client.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsAndPayloads
+```
+
+Get all feature flags and their payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+posthog.get_all_flags_and_payloads('distinct_id_of_your_user')
+```
+
+## Evaluate flags
+
+### `Client.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[List[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+Local evaluation is transparent: when the poller resolves a flag, the
+snapshot's `$feature_flag_called` events are tagged `locally_evaluated=True`
+and reason `"Evaluated locally"`.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If True, never fall back to remote evaluation — flags that can't be evaluated locally are omitted from the snapshot and listed with a reason in its `unresolved_flags`. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[List[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is True. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagEvaluations` | A `FeatureFlagEvaluations` snapshot.
+
+**Examples:**
+
+```python
+flags = posthog.evaluate_flags(
+    "user_123",
+    person_properties={"plan": "enterprise"},
+)
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+## Group identify
+
+### `Client.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+Identify a group and set its properties.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | The type of group (e.g., 'company', 'team'). Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | The unique identifier for the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | A dictionary of properties to set on the group. | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | The timestamp of the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[Union[str, UUID]]` | A unique identifier for the event. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this event. | `None`
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user performing the action. Falls back to the context distinct ID, then to `$<group_type>_<group_key>`. | `None`
+`options` | `Optional[Dict[str, Any]]` | Capture options for this event, sent as given. | `None`
+
+**Examples:**
+
+```python
+posthog.group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+Note: This method will not raise exceptions. Errors are logged.
+
+## Is feature enabled
+
+### `Client.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Check if a feature flag is enabled for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`only_evaluate_locally` | `bool` | Whether to only evaluate locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    # Do something differently for this user
+    # Optional: fetch the payload
+    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+## Shutdown
+
+### `Client.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.
+
+Failed or undrainable events may be dropped and reported through logging
+or `on_error`; returning does not guarantee server receipt. Lifecycle
+cleanup is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+posthog.join()
+```
+
+### `Client.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the client.
+
+Call this for final process cleanup or when disposing of a client that
+will not be reused. It closes capture lanes, stops background workers and
+the feature flag poller, and tears down integrations. Do not call it at the
+end of each request or serverless invocation when the client is shared;
+call `flush()` before returning instead. A shut-down client cannot be
+reused; create a new client if needed.
+
+Normally this method blocks until queued events have been attempted and
+cleanup finishes. Failed or undrainable events may be dropped and
+reported through logging or `on_error`; returning does not guarantee
+server receipt. Event draining has no timeout. Queued spans get one final
+flush with up to 30 seconds waiting for an in-flight flush, then a fresh
+30-second drain budget; the last HTTP request is not cut short. Any spans
+it cannot send are discarded with a warning, as are spans still open.
+Lifecycle cleanup is attempted once, and cleanup failures
+are logged without retry. When called directly from an SDK callback such as
+`on_error`, shutdown is deferred to avoid blocking the worker that
+invoked the callback. If the callback must coordinate a blocking
+shutdown, have it signal an
+application-owned thread and return before that thread calls shutdown.
+Do not wait inside the callback for another thread or task that calls a
+lifecycle method.
+
+**Examples:**
+
+```python
+posthog.shutdown()
+```
+
+## Flag definition loader
+
+### `Client.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flags for local evaluation.
+
+**Examples:**
+
+```python
+posthog.load_feature_flags()
+```
+
+### `Client.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Return feature flag definitions loaded for local evaluation.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The currently loaded feature flag definitions, or `None` before local evaluation has loaded definitions.
+
+## SDK utils
+
+### `Client.queue`
+
+```python
+queue: Queue
+```
+
+The analytics lane's queue (kept for backwards compatibility).
+
+### `Client.consumers`
+
+```python
+consumers: Optional[List[Consumer]]
+```
+
+Flat list of the lanes' consumers, analytics first (kept for backwards compatibility).
+
+### `Client.new_context`
+
+```python
+new_context(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+with client.new_context():
+    client.identify_context('<distinct_id>')
+    client.capture('event_name')
+```
+
+### `Client.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the wrapped function using this client.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to create a fresh context that doesn't inherit from parent. | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting. | `None`
+
+### `Client.tag`
+
+```python
+tag(name: str, value: Any) -> None
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key. | *required*
+`value` | `Any` | The tag value. | *required*
+
+### `Client.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context.
+
+### `Client.set_context_option`
+
+```python
+set_context_option(key: str, value: Any) -> None
+```
+
+Set a capture option for every event captured within the current context.
+
+Context options fill options an event leaves unset, before
+`before_send` runs, so the hook sees them. They override
+`super_options`. An event's own `options` override them, and
+`before_send` can change them.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The option name, such as `"process_person_profile"`. | *required*
+`value` | `Any` | The option value, sent as given. | *required*
+
+### `Client.get_context_options`
+
+```python
+get_context_options() -> Dict[str, Any]
+```
+
+Get all capture options from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all capture options in the current context.
+
+### `Client.identify_context`
+
+```python
+identify_context(distinct_id: str) -> None
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_session`
+
+```python
+set_context_session(session_id: str) -> None
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children. | *required*
+
+### `Client.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str) -> None
+```
+
+Set the device ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children. | *required*
+
+### `Client.feature_flags`
+
+```python
+feature_flags
+```
+
+Get the local evaluation feature flags.
+
+### `Client.get_feature_payloads`
+
+```python
+get_feature_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> dict[str, Optional[str]]
+```
+
+Get feature flag payloads for a user, preserving valid serialized JSON.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The distinct ID of the user. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+payloads = posthog.get_feature_payloads('<distinct_id>')
+```
+
+### `Client.get_flags_decision`
+
+```python
+get_flags_decision(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys_to_evaluate: Optional[list[str]] = None, device_id: Optional[str] = None) -> FlagsResponse
+```
+
+Get feature flags decision.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The distinct ID of the user. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | A dictionary of group information. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | A dictionary of person properties. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | A dictionary of group properties. | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP for this request. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | A list of specific flag keys to evaluate. If provided, only these flags will be evaluated, improving performance. | `None`
+`device_id` | `Optional[str]` | The device ID for this request. | `None`
+
+**Examples:**
+
+```python
+decision = posthog.get_flags_decision('user123')
+```
+
+### `Client.metrics`
+
+```python
+metrics: PostHogMetrics
+```
+
+The `posthog.metrics` API: a statsd-style pre-aggregating metrics client — alpha.
+
+Samples fold into per-series aggregates in memory and flush as one OTLP
+data point per series per window, so recording from hot paths is cheap.
+Configure via the `metrics` client option; pending metrics flush on
+`shutdown()`.
+
+**Examples:**
+
+```python
+client = Posthog("<ph_project_api_key>", metrics={"service_name": "billing-worker"})
+client.metrics.count("invoices.processed", 1, attributes={"plan": "pro"})
+client.metrics.gauge("queue.depth", 42)
+client.metrics.histogram("job.duration", 187, unit="ms")
+```
+
+### `Client.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The remote config feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag, or `None` if the client is disabled, no personal API key is configured, or the request fails. Encrypted payloads are decrypted by PostHog before being returned.
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires `secret_key` for authentication.
+
+</details>
+
+### `Client.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[FeatureFlagEvaluationRuntime]` | The flag's evaluation runtime, or `None` when local evaluation has not loaded a definition for this key. A definition that carries no runtime reports `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+runtime = posthog.get_feature_flag_evaluation_runtime("my-flag")
+if runtime is FeatureFlagEvaluationRuntime.SERVER:
+    ...
+```
+
+### `Client.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime,
+so it is returned for `CLIENT` and for `SERVER`, and asking for
+`ALL` returns every loaded flag. Use this to decide which flags to hand
+to a browser when a backend serves flags to its own frontend.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`evaluation_runtime` | `Union[FeatureFlagEvaluationRuntime, str]` | The runtime to match, as a `FeatureFlagEvaluationRuntime` or its string value. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`list[str]` | The matching flag keys, in the order local evaluation loaded them. Empty when no definitions are loaded.
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime
+
+client_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(
+    FeatureFlagEvaluationRuntime.CLIENT
+)
+```
+
+### `posthog.integrations.django.PosthogContextMiddleware`
+
+```python
+PosthogContextMiddleware(get_response)
+```
+
+Middleware to automatically track Django requests.
+
+This middleware wraps all calls with a posthog context. It attempts to extract the following from the request:
+- Session ID, (extracted from `X-POSTHOG-SESSION-ID`)
+- Distinct ID, (extracted from `X-POSTHOG-DISTINCT-ID`, falling back to the authenticated request user ID)
+- Authenticated user email as `email`
+- Request URL as `$current_url`
+- Request method as `$request_method`
+- Request path as `$request_path`
+- Forwarded IP address as `$ip`
+- User agent as `$user_agent`
+
+Configure the integration with these Django settings:
+- `POSTHOG_MW_CLIENT`: client used for automatic exception capture, or the global client.
+  This does not redirect events explicitly captured through other clients.
+- `POSTHOG_MW_CAPTURE_EXCEPTIONS`: `False` enables context enrichment only;
+  `True` enables automatic exception capture; `None` inherits the effective client's
+  `enable_exception_autocapture`. When omitted, the legacy default is `True`.
+- `POSTHOG_MW_REQUEST_FILTER`: a callback receiving the request. Returning `False`
+  disables both enrichment and automatic exception capture for that request.
+- `POSTHOG_MW_EXTRA_PROPERTIES`: a callback returning additional event properties.
+- `POSTHOG_MW_CAPTURE_TRACING_HEADERS`: read PostHog identity and session headers
+  as request-scoped analytics context (default: `True`). Explicit capture IDs and
+  event properties take precedence. These values are never authentication or
+  authorization. Authenticated Django user identity remains the fallback when no
+  usable header ID is available or header capture is disabled.
+- `POSTHOG_MW_TRUST_TRACING_HEADERS`: deprecated alias for
+  `POSTHOG_MW_CAPTURE_TRACING_HEADERS`; the capture-named setting takes precedence.
+- `POSTHOG_MW_PROPERTIES_MAP`: an optional callback transforming request properties.
+
+The old `POSTHOG_MW_EXTRA_TAGS` and `POSTHOG_MW_TAG_MAP` settings remain aliases;
+the property-named settings take precedence when both are configured.
+
+Request properties are included on all events captured within the active context,
+including when automatic exception capture is disabled.
+See the context documentation for more information. The extracted distinct ID and session ID,
+if found, are used to associate all events captured in the middleware context with the same distinct ID
+and session as currently active on the frontend. See the documentation for `set_context_session`
+and `identify_context` for more details.
+
+This middleware is hybrid-capable: it supports both WSGI (sync) and ASGI (async) Django applications. The middleware
+detects at initialization whether the next middleware in the chain is async or sync, and adapts its behavior accordingly.
+This ensures compatibility with both pure sync and pure async middleware chains, as well as mixed chains in ASGI mode.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`aextract_properties` | Async version of extract_properties for use in async request handling.
+`aextract_request_user` | Async version of extract_request_user for use in async request handling.
+`aextract_tags` | Compatibility alias for `aextract_properties`.
+`extract_properties` | Extract event properties and identity from a synchronous request.
+`extract_request_user` | Extract user ID and email from request in sync context.
+`extract_tags` | Compatibility alias for `extract_properties`.
+`process_exception` | Process exceptions from views and downstream middleware.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`async_capable` |  | 
+`capture_exceptions` | `Optional[bool]` | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`extra_tags` |  | Compatibility alias for `extra_properties`.
+`get_response` |  | 
+`properties_map` |  | 
+`request_filter` |  | 
+`sync_capable` |  | 
+`tag_map` |  | Compatibility alias for `properties_map`.
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+Initialize the middleware with Django's next handler.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`get_response` |  | The next middleware or view handler in Django's middleware chain. May be synchronous or asynchronous. | 
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_properties`
+
+```python
+async aextract_properties(request)
+```
+
+Async version of extract_properties for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_request_user`
+
+```python
+async aextract_request_user(request)
+```
+
+Async version of extract_request_user for use in async request handling.
+
+Uses await request.auser() instead of request.user to avoid
+SynchronousOnlyOperation in async context.
+
+Follows Django's naming convention for async methods (auser, asave, etc.).
+
+#### `posthog.integrations.django.PosthogContextMiddleware.aextract_tags`
+
+```python
+async aextract_tags(request)
+```
+
+Compatibility alias for `aextract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.async_capable`
+
+```python
+async_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_exceptions`
+
+```python
+capture_exceptions: Optional[bool] = capture_exceptions if (capture_exceptions is None or isinstance(capture_exceptions, bool)) else True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers, canonical_name='POSTHOG_MW_CAPTURE_TRACING_HEADERS', deprecated_name='POSTHOG_MW_TRUST_TRACING_HEADERS')
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.client`
+
+```python
+client = cast('Optional[Client]', settings.POSTHOG_MW_CLIENT)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_properties`
+
+```python
+extra_properties = cast('Callable[[HttpRequest], Dict[str, Any]]', extra_properties) if callable(extra_properties) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extra_tags`
+
+```python
+extra_tags
+```
+
+Compatibility alias for `extra_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_properties`
+
+```python
+extract_properties(request)
+```
+
+Extract event properties and identity from a synchronous request.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_request_user`
+
+```python
+extract_request_user(request)
+```
+
+Extract user ID and email from request in sync context.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.extract_tags`
+
+```python
+extract_tags(request)
+```
+
+Compatibility alias for `extract_properties`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.get_response`
+
+```python
+get_response = get_response
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.process_exception`
+
+```python
+process_exception(request, exception)
+```
+
+Process exceptions from views and downstream middleware.
+
+Django calls this WHILE still inside the context created by __call__,
+so request tags have already been extracted and set. This method just
+needs to capture the exception directly.
+
+Django converts view exceptions into responses before they propagate through
+the middleware stack, so the context manager in __call__/__acall__ never sees them.
+
+Note: Django's process_exception is always synchronous, even for async views.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.properties_map`
+
+```python
+properties_map = cast('Callable[[Dict[str, Any]], Dict[str, Any]]', properties_map) if callable(properties_map) else None
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.request_filter`
+
+```python
+request_filter = cast('Optional[Callable[[HttpRequest], bool]]', settings.POSTHOG_MW_REQUEST_FILTER)
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.sync_capable`
+
+```python
+sync_capable = True
+```
+
+#### `posthog.integrations.django.PosthogContextMiddleware.tag_map`
+
+```python
+tag_map
+```
+
+Compatibility alias for `properties_map`.
+
+#### `posthog.integrations.django.PosthogContextMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.flask.PosthogFlaskIntegration`
+
+```python
+PosthogFlaskIntegration(app: Optional[Flask] = None, *, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[Callable[[Request], bool]] = None, extra_properties: Optional[Callable[[Request], Mapping[str, Any]]] = None, trust_tracing_headers: Optional[bool] = None, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog request context and exception tracking to a Flask app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `Optional[Flask]` | An optional Flask application. If omitted, call `init_app` later (the Flask application-factory pattern). | `None`
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions that reach Flask's unhandled exception machinery. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[Callable[[Request], bool]]` | Optional callback receiving Flask's request object. A false return value disables both context and exception capture for that request. | `None`
+`extra_properties` | `Optional[Callable[[Request], Mapping[str, Any]]]` | Optional callback returning additional event properties. This is useful for application-specific metadata such as an authenticated user's role. Values should not contain secrets or request bodies. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+The integration intentionally does not capture exceptions handled by an
+application error handler, expected HTTP exceptions, request or response
+bodies, query strings, cookies, authorization headers, or arbitrary headers.
+Call `capture_exception` explicitly from a custom error handler if a
+handled exception should be reported.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`init_app` | Register the integration with a Flask application once.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.init_app`
+
+```python
+init_app(app: Flask) -> None
+```
+
+Register the integration with a Flask application once.
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.flask.PosthogFlaskIntegration.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.asgi.PosthogASGIMiddleware`
+
+```python
+PosthogASGIMiddleware(app: _ASGIApp, client: Optional[Client] = None, capture_exceptions: Optional[bool] = None, request_filter: Optional[_RequestFilter] = None, extra_properties: Optional[_ExtraProperties] = None, trust_tracing_headers: Optional[bool] = None, *, capture_tracing_headers: Optional[bool] = None) -> None
+```
+
+Add PostHog context and automatic exception capture to an ASGI app.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`app` | `_ASGIApp` | The downstream ASGI application. | *required*
+`client` | `Optional[Client]` | Optional destination for automatically captured exceptions. The global client is used by default. Request context still enriches events captured through any client and does not redirect capture calls. | `None`
+`capture_exceptions` | `Optional[bool]` | Capture exceptions escaping the downstream app. If omitted, inherit the effective client's `enable_exception_autocapture` setting. Pass `True` or `False` to override it. | `None`
+`request_filter` | `Optional[_RequestFilter]` | Optional sync or async callback receiving the ASGI scope. Returning `False` bypasses all instrumentation for that scope. | `None`
+`extra_properties` | `Optional[_ExtraProperties]` | Optional sync or async callback receiving the ASGI scope and returning additional event properties. | `None`
+`capture_tracing_headers` | `Optional[bool]` | Read PostHog distinct and session ID headers as request-scoped analytics context. Defaults to True. Explicit capture IDs and event properties take precedence. Never use these values for security. | `None`
+`trust_tracing_headers` | `Optional[bool]` | Deprecated alias for `capture_tracing_headers`. The capture-named option takes precedence when both are supplied. | `None`
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`app` |  | 
+`capture_exceptions` |  | 
+`capture_tracing_headers` |  | 
+`client` |  | 
+`extra_properties` |  | 
+`request_filter` |  | 
+`trust_tracing_headers` | `bool` | Deprecated alias for `capture_tracing_headers`.
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.app`
+
+```python
+app = app
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.capture_tracing_headers`
+
+```python
+capture_tracing_headers = _resolve_capture_tracing_headers(capture_tracing_headers, trust_tracing_headers)
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.extra_properties`
+
+```python
+extra_properties = extra_properties
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.request_filter`
+
+```python
+request_filter = request_filter
+```
+
+#### `posthog.integrations.asgi.PosthogASGIMiddleware.trust_tracing_headers`
+
+```python
+trust_tracing_headers: bool
+```
+
+Deprecated alias for `capture_tracing_headers`.
+
+### `posthog.integrations.celery.PosthogCeleryIntegration`
+
+```python
+PosthogCeleryIntegration(client: Optional[Client] = None, capture_exceptions: bool = True, capture_task_lifecycle_events: bool = True, propagate_context: bool = True, task_filter: Optional[Callable[[Optional[str], dict[str, Any]], bool]] = None)
+```
+
+Celery integration that captures task lifecycle events and exceptions.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`client` | `Optional[Client]` | Optional `Client` instance. When provided, all events and exceptions are captured through this client rather than the global `posthog` module. Don't skip this if using a custom flag definition cache provider, and pass the custom `Client` instance here initialized with the custom provider so fork safety for that provider is handled correctly. | `None`
+`capture_exceptions` | `bool` | Whether to capture task exceptions via `capture_exception` (default `True`). | `True`
+`capture_task_lifecycle_events` | `bool` | Whether to emit lifecycle events of the task such as "started", "success", "failure" etc. (default `True`). | `True`
+`propagate_context` | `bool` | Whether to propagate PostHog context (distinct ID, session ID, tags) from the producer to the worker via task headers (default `True`). | `True`
+`task_filter` | `Optional[Callable[[Optional[str], dict[str, Any]], bool]]` | Optional callback `(task_name, task_properties) -> bool` expected to return `False` if a given task should not be tracked. | `None`
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`instrument` | Connect Celery signal handlers to capture task events and exceptions. Call this after initializing the PostHog client and this integration.
+`shutdown` | Disconnect all signal handlers registered by `instrument()`, flush all pending events and cleanly shutdown the integration.
+`uninstrument` | Disconnect Celery signal handlers and unregister exit cleanup.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_exceptions` |  | 
+`capture_task_lifecycle_events` |  | 
+`client` |  | 
+`propagate_context` |  | 
+`task_filter` |  | 
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_exceptions`
+
+```python
+capture_exceptions = capture_exceptions
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.capture_task_lifecycle_events`
+
+```python
+capture_task_lifecycle_events = capture_task_lifecycle_events
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.client`
+
+```python
+client = client
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.instrument`
+
+```python
+instrument() -> None
+```
+
+Connect Celery signal handlers to capture task events and exceptions.
+Call this after initializing the PostHog client and this integration.
+
+If Celery runs on a single host, reinstrumenting in worker children is
+not strictly necessary because the PostHog client and this integration
+are fork-safe. If Celery workers run across multiple hosts, each worker
+process must initialize PostHog, this integration, and call
+`instrument()`. Celery provides `worker_process_init` signal to help
+with this.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.propagate_context`
+
+```python
+propagate_context = propagate_context
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Disconnect all signal handlers registered by `instrument()`, flush all pending events
+and cleanly shutdown the integration.
+
+`shutdown()` is also registered on `worker_process_shutdown` and `atexit` signals,
+but there is no guarantee those will always be called, so we strongly recommend calling
+it manually when the integration is no longer needed to avoid data loss.
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.task_filter`
+
+```python
+task_filter = task_filter
+```
+
+#### `posthog.integrations.celery.PosthogCeleryIntegration.uninstrument`
+
+```python
+uninstrument() -> None
+```
+
+Disconnect Celery signal handlers and unregister exit cleanup.
+
+Do not use directly, call `shutdown()` instead.
+
+### `posthog.request.set_socket_options`
+
+```python
+set_socket_options(socket_options: Optional[SocketOptions]) -> None
+```
+
+Configure socket options for all SDK HTTP connections.
+
+Call this during initialization, before making API requests. Pass `None`
+to reset to the default socket behavior.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`socket_options` | `Optional[SocketOptions]` | A list of `(level, option, value)` tuples accepted by urllib3/`socket.setsockopt()`, or `None` to reset defaults. | *required*
+
+<details class="example" open markdown="1">
+<summary>Example</summary>
+
+from posthog import set_socket_options
+set_socket_options([(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)])
+
+</details>
+
+### `posthog.request.enable_keep_alive`
+
+```python
+enable_keep_alive() -> None
+```
+
+Enable TCP keepalive for SDK HTTP connections.
+
+This helps prevent idle pooled connections from being dropped by network
+infrastructure. Call during initialization, before making API requests.
+
+### `posthog.request.disable_connection_reuse`
+
+```python
+disable_connection_reuse() -> None
+```
+
+Disable HTTP connection reuse for SDK requests.
+
+Each request will create a fresh connection. This can avoid issues with
+environments that terminate pooled connections, but adds per-request
+overhead. Call during initialization, before making API requests.
+
+## AsyncClient
+
+Needs the `async` extra, `posthog[async]`.
+
+### `AsyncClient(...)`
+
+```python
+AsyncClient(project_api_key: str, host: Optional[str] = None, *, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, super_options: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, privacy_mode: bool = False, enable_full_ai_capture: bool = False, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2) -> None
+```
+
+### `AsyncClient.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Queue an event without blocking for network delivery.
+
+### `AsyncClient.capture_immediate`
+
+```python
+async capture_immediate(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture one event and wait until its delivery attempt completes.
+
+### `AsyncClient.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+### `AsyncClient.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: Optional[str], timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+### `AsyncClient.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, *, level: Optional[str] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an exception. This method never raises, including in debug mode.
+
+`level` sets `$exception_level` and defaults to `"error"`. An unknown
+value counts as unset. Reserved exception properties in `properties`,
+such as `$exception_list` and `$exception_level`, are ignored.
+
+When OpenTelemetry is installed and a valid span is active, its trace and
+span IDs are added as `$trace_id` and `$span_id` event properties,
+unless the event, a context tag or `super_properties` sets either one.
+
+### `AsyncClient.emails`
+
+```python
+emails: AsyncEmails
+```
+
+Send transactional email from PostHog email templates, and read the
+status of each email sent with `get`.
+
+Needs `secret_key`, a project secret API key with the `hog_flow:write`
+scope, and `posthog[async]`. Sends go to `app_host`, or to the PostHog
+Cloud app host of `host`. `email_request_timeout_seconds` and
+`email_request_max_retries` configure each send. A disabled or shut-down
+client sends nothing. See `posthog.emails` for setup.
+
+**Examples:**
+
+```python
+await client.emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    distinct_id="user_123",
+)
+```
+
+### `AsyncClient.flush`
+
+```python
+async flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+### `AsyncClient.evaluate_flags`
+
+```python
+async evaluate_flags(distinct_id: Optional[ID_TYPES] = None, *, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate flags remotely without blocking the event loop.
+
+The returned snapshot has synchronous in-memory accessors. Pass it to
+`capture(flags=...)` to attach the exact values used for branching.
+This client does not evaluate flags locally, so the snapshot's
+`unresolved_flags` is always empty.
+
+### `AsyncClient.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime, str]] = None, uuid: Optional[Union[str, UUID]] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+### `AsyncClient.shutdown`
+
+```python
+async shutdown() -> None
+```
+
+### `AsyncClient.join`
+
+```python
+async join() -> None
+```
+
+### `AsyncClient.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Queue an AI event for the AI capture endpoint without blocking.
+
+Takes the same arguments and returns the same value as `capture()`.
+The event uses a separate queue with a larger per-event size cap. The
+payload is sent as given, with no redaction or truncation.
+
+### `AsyncClient.capture_ai_immediate`
+
+```python
+async capture_ai_immediate(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture one AI event and wait until its delivery attempt completes.
+
+Uses the AI capture endpoint and the `capture_ai_*` settings.
+
+### `AsyncClient.get_remote_config_payload`
+
+```python
+async get_remote_config_payload(key: str) -> Optional[Any]
+```
+
+Fetch and decrypt a remote-config payload without blocking the loop.
+
+## Module functions
+
+### `posthog.new_context`
+
+```python
+new_context(fresh: bool = False, capture_exceptions: Optional[bool] = None, client: Optional[Client] = None)
+```
+
+Create a new context scope that will be active for the duration of the with block.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` | `bool` | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting. | `None`
+`client` | `Optional[Client]` | Optional Posthog client instance to use for this context (default: None) | `None`
+
+**Examples:**
+
+```python
+from posthog import new_context, tag, capture
+with new_context():
+    tag("request_id", "123")
+    capture("event_name", properties={"property": "value"})
+```
+
+### `posthog.scoped`
+
+```python
+scoped(fresh=False, capture_exceptions: Optional[bool] = None)
+```
+
+Decorator that creates a new context for the function.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`fresh` |  | Whether to start with a fresh context (default: False) | `False`
+`capture_exceptions` | `Optional[bool]` | Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting. | `None`
+
+**Examples:**
+
+```python
+from posthog import scoped, tag, capture
+@scoped()
+def process_payment(payment_id):
+    tag("payment_id", payment_id)
+    capture("payment_started")
+```
+
+### `posthog.set_context_session`
+
+```python
+set_context_session(session_id: str)
+```
+
+Set the session ID for the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`session_id` | `str` | The session ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_session
+set_context_session("session_123")
+```
+
+### `posthog.set_context_device_id`
+
+```python
+set_context_device_id(device_id: str)
+```
+
+Set the device ID for the current context, associating all feature flag requests
+in this or child contexts with the given device ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`device_id` | `str` | The device ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import set_context_device_id
+set_context_device_id("device_123")
+```
+
+### `posthog.identify_context`
+
+```python
+identify_context(distinct_id: str)
+```
+
+Identify the current context with a distinct ID.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `str` | The distinct ID to associate with the current context and its children | *required*
+
+**Examples:**
+
+```python
+from posthog import identify_context
+identify_context("user_123")
+```
+
+### `posthog.set_capture_exception_code_variables_context`
+
+```python
+set_capture_exception_code_variables_context(enabled: bool)
+```
+
+Override code-variable capture for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`enabled` | `bool` | Whether exceptions captured in this context should include local variable values from stack frames. | *required*
+
+### `posthog.set_code_variables_mask_patterns_context`
+
+```python
+set_code_variables_mask_patterns_context(mask_patterns: list[str])
+```
+
+Override code-variable mask patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`mask_patterns` | `list[str]` | Variable-name patterns whose values should be replaced with `***` when code variables are captured. | *required*
+
+### `posthog.set_code_variables_ignore_patterns_context`
+
+```python
+set_code_variables_ignore_patterns_context(ignore_patterns: list[str])
+```
+
+Override code-variable ignore patterns for exceptions in the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`ignore_patterns` | `list[str]` | Variable-name patterns that should be omitted entirely when code variables are captured. | *required*
+
+### `posthog.set_code_variables_mask_url_credentials_context`
+
+```python
+set_code_variables_mask_url_credentials_context(enabled: bool)
+```
+
+Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from
+captured code variables for the current context.
+
+### `posthog.set_code_variables_detect_secrets_context`
+
+```python
+set_code_variables_detect_secrets_context(enabled: bool)
+```
+
+Whether to apply entropy-based secret detection as a last-resort redaction of
+high-entropy values (API keys, tokens, strong passwords) in captured code
+variables for the current context.
+
+### `posthog.tag`
+
+```python
+tag(name: str, value: Any)
+```
+
+Add a tag to the current context.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | The tag key | *required*
+`value` | `Any` | The tag value | *required*
+
+**Examples:**
+
+```python
+from posthog import tag
+tag("user_id", "123")
+```
+
+### `posthog.get_tags`
+
+```python
+get_tags() -> Dict[str, Any]
+```
+
+Get all tags from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all tags in the current context
+
+### `posthog.set_context_option`
+
+```python
+set_context_option(key: str, value: Any) -> None
+```
+
+Set a capture option for every event captured within the current context.
+
+Context options fill options an event leaves unset, before `before_send`
+runs, so the hook sees them. They override `super_options`. An event's
+own `options` override them, and `before_send` can change them.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The option name, such as `"process_person_profile"` | *required*
+`value` | `Any` | The option value, sent as given | *required*
+
+**Examples:**
+
+```python
+from posthog import new_context, set_context_option
+with new_context():
+    set_context_option("process_person_profile", False)
+```
+
+### `posthog.get_context_options`
+
+```python
+get_context_options() -> Dict[str, Any]
+```
+
+Get all capture options from the current context.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Dict[str, Any]` | Dict of all capture options in the current context
+
+### `posthog.capture`
+
+```python
+capture(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture anything a user does within your system.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name to specify the event | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional arguments including: distinct_id: Unique identifier for the user properties: Dict of event properties timestamp: When the event occurred. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this event. If omitted, one is generated     and returned. If provided, it must be a valid UUID string or     uuid.UUID instance; invalid values are ignored and replaced with     a newly generated UUID. groups: Dict of group types and IDs flags: A FeatureFlagEvaluations snapshot from evaluate_flags(). The     exact values from the snapshot are attached with no extra /flags     request. send_feature_flags: Deprecated. Prefer flags=... from     evaluate_flags(). When truthy, evaluates flags during capture and     attaches them to the event. disable_geoip: Whether to disable GeoIP lookup | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.
+
+</details>
+
+**Examples:**
+
+```python
+# Context and capture usage
+from posthog import new_context, identify_context, tag, capture
+# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)
+with new_context():
+    # Associate this context with some user, by distinct_id
+    identify_context('some user')
+
+    # Capture an event, associated with the context-level distinct ID ('some user')
+    capture('movie started')
+
+    # Capture an event associated with some other user (overriding the context-level distinct ID)
+    capture('movie joined', distinct_id='some-other-user')
+
+    # Capture an event with some properties
+    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})
+
+    # Capture an event with some properties
+    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})
+    # Capture an event with some associated group
+    capture('purchase', groups={'company': 'id:5'})
+
+    # Adding a tag to the current context will cause it to appear on all subsequent events
+    tag('some-tag', 'some-value')
+
+    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict
+```
+```python
+# Set event properties
+from posthog import capture
+capture(
+    "user_signed_up",
+    distinct_id="distinct_id_of_the_user",
+    properties={
+        "login_type": "email",
+        "is_free_trial": "true"
+    }
+)
+```
+
+### `posthog.capture_ai`
+
+```python
+capture_ai(event: str, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture an AI event on the dedicated AI capture endpoint.
+
+Beta: the signature is stable; operational limits (per-event size cap,
+batching, endpoint) may change without notice.
+
+Takes the same arguments and returns the same value as `capture()`: the
+event UUID, or None when the event was not admitted (disabled client, or
+dropped by `before_send`). The event is delivered on an isolated queue
+with its own consumer pool and a higher per-event size cap, posting to
+the dedicated AI ingestion endpoint. The payload is sent as given — no
+redaction or truncation is applied here.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`event` | `str` | The event name, normally one of the `$ai_*` event names. | *required*
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Same optional arguments as `capture()`. | `{}`
+
+**Examples:**
+
+```python
+from posthog import capture_ai
+
+uuid = capture_ai(
+    "$ai_generation",
+    distinct_id="user_123",
+    properties={"$ai_model": "gpt-5"},
+)
+```
+
+### `posthog.set`
+
+```python
+set(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).
+
+</details>
+
+**Examples:**
+
+```python
+# Set person properties
+from posthog import set
+set(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})
+```
+
+### `posthog.set_once`
+
+```python
+set_once(**kwargs: Unpack[OptionalSetArgs]) -> Optional[str]
+```
+
+Set properties on a user record, only if they do not yet exist.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`**kwargs` | `Unpack[OptionalSetArgs]` | Optional arguments including: distinct_id: Unique identifier for the user. Falls back to the     context distinct ID; if none exists, this call does nothing. properties: Dict of person properties to set only once. timestamp: When the properties were set. UTC is preferred; non-UTC     datetimes and parseable ISO timestamp strings are converted to UTC. uuid: Unique identifier for this operation. If omitted, one is     generated and returned. If provided, it must be a valid UUID     string or uuid.UUID instance; invalid values are ignored and     replaced with a newly generated UUID. disable_geoip: Whether to disable GeoIP lookup. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.
+
+</details>
+
+**Examples:**
+
+```python
+# Set property once
+from posthog import set_once
+set_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})
+
+```
+
+### `posthog.group_identify`
+
+```python
+group_identify(group_type: str, group_key: str, properties: Optional[Dict[str, Any]] = None, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, distinct_id: Optional[ID_TYPES] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+Set properties on a group.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`group_type` | `str` | Type of your group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`group_key` | `str` | Unique identifier of the group. Required - the call is dropped with a warning if it is missing or empty. | *required*
+`properties` | `Optional[Dict[str, Any]]` | Properties to set on the group | `None`
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`distinct_id` | `Optional[ID_TYPES]` | Optional distinct ID of the user performing the action | `None`
+`options` | `Optional[Dict[str, Any]]` | Optional capture options for the event, sent as given | `None`
+
+**Examples:**
+
+```python
+# Group identify
+from posthog import group_identify
+group_identify('company', 'company_id_in_your_db', {
+    'name': 'Awesome Inc.',
+    'employees': 11
+})
+```
+
+### `posthog.alias`
+
+```python
+alias(previous_id: ID_TYPES, distinct_id: str, timestamp: Optional[Union[datetime.datetime, str]] = None, uuid: Optional[str] = None, disable_geoip: Optional[bool] = None, options: Optional[Dict[str, Any]] = None) -> Optional[str]
+```
+
+Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`previous_id` | `ID_TYPES` | The unique ID of the user before | *required*
+`distinct_id` | `str` | The current unique id | *required*
+`timestamp` | `Optional[Union[datetime, str]]` | Optional timestamp for the event. UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | `None`
+`uuid` | `Optional[str]` | Optional UUID for the event | `None`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`options` | `Optional[Dict[str, Any]]` | Optional capture options for the event, sent as given | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like "Which marketing channels leads to users churning after a month?" or "What do users do on our website before signing up?". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.
+
+</details>
+
+**Examples:**
+
+```python
+# Alias user
+from posthog import alias
+alias(previous_id='distinct_id', distinct_id='alias_id')
+```
+
+### `posthog.capture_exception`
+
+```python
+capture_exception(exception: Optional[ExceptionArg] = None, *, level: Optional[str] = None, **kwargs: Unpack[OptionalCaptureArgs]) -> Optional[str]
+```
+
+Capture exceptions that happen in your code.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`exception` | `Optional[ExceptionArg]` | The exception to capture. If not provided, the current exception is captured via `sys.exc_info()` | `None`
+`level` | `Optional[str]` | The `$exception_level`, such as `"warning"` or `"fatal"`. Defaults to `"error"`. An unknown value counts as unset. | `None`
+`**kwargs` | `Unpack[OptionalCaptureArgs]` | Optional capture arguments including distinct_id, properties, timestamp, uuid, groups, flags, send_feature_flags, disable_geoip, and options. Reserved exception properties in `properties`, such as `$exception_list` and `$exception_level`, are ignored. | `{}`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the "traceback"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError("Some Error"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.
+
+</details>
+
+**Examples:**
+
+```python
+# Capture exception
+from posthog import capture_exception
+try:
+    risky_operation()
+except Exception as e:
+    capture_exception(e)
+```
+
+### `posthog.feature_enabled`
+
+```python
+feature_enabled(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[bool]
+```
+
+Use feature flags to enable or disable features for users.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.
+
+</details>
+
+**Examples:**
+
+```python
+# Boolean feature flag
+from posthog import feature_enabled, get_feature_flag_payload
+is_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')
+if is_my_flag_enabled:
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag`
+
+```python
+get_feature_flag(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FlagValue]
+```
+
+Get feature flag variant for users. Used with experiments.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping from group type to group key | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties in format { group_type_name: { group_properties } } | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`send_feature_flag_events` | `bool` | Whether to send feature flag events | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+`groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5", you would pass groups={"organization": "5"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count, you'll send these as: group_properties={"organization": {"name": "PostHog", "employees": 11}}.
+
+</details>
+
+**Examples:**
+
+```python
+# Multivariate feature flag
+from posthog import get_feature_flag, get_feature_flag_payload
+enabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')
+if enabled_variant == 'variant-key':
+    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')
+```
+
+### `posthog.get_all_flags`
+
+```python
+get_all_flags(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> Optional[dict[str, FlagValue]]
+```
+
+Get all flags for a given user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Groups mapping | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate (evaluates all if None) | `None`
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.
+
+</details>
+
+**Examples:**
+
+```python
+# All flags for user
+from posthog import get_all_flags
+get_all_flags('distinct_id_of_your_user')
+```
+
+### `posthog.get_feature_flag_result`
+
+```python
+get_feature_flag_result(key: str, distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[FeatureFlagResult]
+```
+
+Get a FeatureFlagResult object which contains the flag result and payload.
+
+This method evaluates a feature flag and returns a FeatureFlagResult object containing:
+- enabled: Whether the flag is enabled
+- variant: The variant value if the flag has variants
+- payload: The payload associated with the flag (automatically deserialized from JSON)
+- key: The flag key
+- reason: Why the flag was enabled/disabled
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+Example:
+```python
+result = posthog.get_feature_flag_result('beta-feature', 'distinct_id')
+if result and result.enabled:
+    # Use the variant and payload
+    print(f"Variant: {result.variant}")
+    print(f"Payload: {result.payload}")
+```
+
+### `posthog.get_feature_flag_payload`
+
+```python
+get_feature_flag_payload(key: str, distinct_id: ID_TYPES, match_value: Optional[FlagValue] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, send_feature_flag_events: bool = True, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None) -> Optional[object]
+```
+
+Get the payload associated with a feature flag value.
+
+Deprecated for new code. Prefer `evaluate_flags()` and
+`flags.get_flag_payload(key)` so flag evaluation happens once per request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`match_value` | `Optional[FlagValue]` | Optional flag value to use when selecting a payload. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`send_feature_flag_events` | `bool` | Whether to send a $feature_flag_called event. | `True`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Optional[object]` | The payload associated with the matched feature flag value, or None. This function returns the payload only, not the FeatureFlagResult wrapper used internally to compute it.
+
+### `posthog.get_remote_config_payload`
+
+```python
+get_remote_config_payload(key: str)
+```
+
+Get the payload for a remote config feature flag.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The key of the feature flag | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+ | The payload associated with the feature flag. If payload is encrypted, the return value will be decrypted
+
+<details class="note" open markdown="1">
+<summary>Note</summary>
+
+Requires secret_key to be set for authentication
+
+</details>
+
+### `posthog.get_all_flags_and_payloads`
+
+```python
+get_all_flags_and_payloads(distinct_id: ID_TYPES, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, device_id: Optional[str] = None, flag_keys_to_evaluate: Optional[list[str]] = None) -> FlagsAndPayloads
+```
+
+Get all feature flag values and payloads for a user.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `ID_TYPES` | The user's distinct ID. | *required*
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | Whether to evaluate only locally. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`device_id` | `Optional[str]` | Optional device ID override for experience-continuity flags. | `None`
+`flag_keys_to_evaluate` | `Optional[list[str]]` | Optional list of flag keys to evaluate. Evaluates all flags when omitted. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FlagsAndPayloads` | A dict with `featureFlags` and `featureFlagPayloads` entries.
+
+### `posthog.evaluate_flags`
+
+```python
+evaluate_flags(distinct_id: Optional[ID_TYPES] = None, groups: Optional[Mapping[str, Union[str, int]]] = None, person_properties: Optional[Dict[str, Any]] = None, group_properties: Optional[Dict[str, Dict[str, Any]]] = None, only_evaluate_locally: bool = False, disable_geoip: Optional[bool] = None, flag_keys: Optional[list[str]] = None, device_id: Optional[str] = None) -> FeatureFlagEvaluations
+```
+
+Evaluate all feature flags for a user in a single call and return a
+`FeatureFlagEvaluations` snapshot. Branch on `.is_enabled()` /
+`.get_flag()` and pass the same snapshot to `capture()` via the
+`flags` option so events carry the exact flag values the code branched on.
+
+Prefer this over repeated `get_feature_flag()` calls and over
+`capture(send_feature_flags=True)` — it consolidates flag evaluation into
+a single `/flags` request per incoming request.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` | `Optional[ID_TYPES]` | The user's distinct ID. If `None`, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. | `None`
+`groups` | `Optional[Mapping[str, Union[str, int]]]` | Mapping of group type to group key. | `None`
+`person_properties` | `Optional[Dict[str, Any]]` | Person properties to use for evaluation. | `None`
+`group_properties` | `Optional[Dict[str, Dict[str, Any]]]` | Group properties keyed by group type. | `None`
+`only_evaluate_locally` | `bool` | If `True`, never fall back to remote evaluation and omit flags that cannot be evaluated locally. The snapshot's `unresolved_flags` lists them with a reason. | `False`
+`disable_geoip` | `Optional[bool]` | Whether to disable GeoIP lookup. | `None`
+`flag_keys` | `Optional[list[str]]` | Optional list that scopes local evaluation, the underlying `/flags` request, and the returned snapshot. When omitted or `None`, all flags are evaluated. An empty list returns an empty snapshot without evaluating flags. A requested key absent from loaded local definitions is included in one remote fallback per `evaluate_flags` call unless `only_evaluate_locally` is `True`. If the server also does not know the key, it is omitted from the snapshot. | `None`
+`device_id` | `Optional[str]` | Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. | `None`
+
+**Examples:**
+
+```python
+from posthog import evaluate_flags, capture
+flags = evaluate_flags("user_123", person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+capture("page_viewed", distinct_id="user_123", flags=flags)
+```
+
+### `posthog.feature_flag_definitions`
+
+```python
+feature_flag_definitions()
+```
+
+Returns loaded feature flags.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import feature_flag_definitions
+definitions = feature_flag_definitions()
+```
+
+### `posthog.get_feature_flag_evaluation_runtime`
+
+```python
+get_feature_flag_evaluation_runtime(key: str) -> Optional[FeatureFlagEvaluationRuntime]
+```
+
+Return where a locally loaded feature flag is meant to be evaluated.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+Reads the `evaluation_runtime` each flag definition carries, so no extra
+request is made. Returns `None` when local evaluation has not loaded a
+definition for this key. A definition that carries no runtime reports
+`FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime
+runtime = get_feature_flag_evaluation_runtime("my-flag")
+```
+
+### `posthog.get_feature_flag_keys_by_evaluation_runtime`
+
+```python
+get_feature_flag_keys_by_evaluation_runtime(evaluation_runtime: Union[FeatureFlagEvaluationRuntime, str]) -> list[str]
+```
+
+Return the keys of locally loaded flags that a runtime can evaluate.
+
+<details class="details" open markdown="1">
+<summary>Details</summary>
+
+A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so
+it is returned for `CLIENT` and for `SERVER`. Use this to decide which
+flags to hand to a browser when a backend serves flags to its own
+frontend.
+
+</details>
+
+**Examples:**
+
+```python
+from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime
+client_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)
+```
+
+### `posthog.load_feature_flags`
+
+```python
+load_feature_flags()
+```
+
+Load feature flag definitions from PostHog.
+
+**Examples:**
+
+```python
+from posthog import load_feature_flags
+load_feature_flags()
+```
+
+### `posthog.flush`
+
+```python
+flush(timeout_seconds: Optional[float] = 10) -> None
+```
+
+Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.
+
+Call `flush()` before a short-lived request or serverless invocation returns
+when using the shared module-level client. Use `shutdown()` only for final
+process cleanup or a client that will not be reused. Flush does not stop the
+background workers or feature flag poller, and does not end open spans.
+
+Returning does not guarantee server receipt: pending work can remain after a
+timeout or span export failure, and failed events may be dropped by consumers.
+Calls made directly from SDK callbacks such as `on_error` are deferred
+rather than blocking the worker that invoked the callback.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`timeout_seconds` | `Optional[float]` | Seconds to wait for event queues to drain, shared across event lanes. Defaults to 10 seconds. Pass `None` to wait without a time limit; this does not guarantee successful delivery. Queued spans flush concurrently, waiting up to this many seconds for an in-flight flush before starting a fresh drain budget. A lock wait timeout leaves the in-flight flush to finish. At least one span request is attempted after acquiring the lock, even with no budget left; retriable failures are retried after backoff while budget remains, with one last attempt at the deadline. The last span request is not cut short and is bounded by the client's `timeout` in seconds, so this is not a strict wall-clock limit for the whole call. With `None`, a retriable span failure is left for a later flush rather than retried within this call. | `10`
+
+**Examples:**
+
+```python
+import posthog
+posthog.capture('event_name', distinct_id='user_id')
+# Before a serverless invocation returns; keep the global client open.
+posthog.flush(timeout_seconds=10)
+```
+
+### `posthog.join`
+
+```python
+join() -> None
+```
+
+Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.
+
+Failed or undrainable events may be dropped and reported through logging or
+`on_error`; returning does not guarantee server receipt. Lifecycle cleanup
+is attempted once, and cleanup failures are logged without retry.
+
+**Examples:**
+
+```python
+from posthog import join
+join()
+```
+
+### `posthog.start_span`
+
+```python
+start_span(name: str, *, kind: Optional[str] = None, attributes: Optional[Mapping[str, Any]] = None, parent: Union[Span, str, None] = None, tracestate: Optional[str] = None, start_time: Union[datetime.datetime, float, None] = None) -> Span
+```
+
+Start a span for distributed tracing. Alpha.
+
+Returns a span handle. Use it as a context manager to make it the active
+span for the block and end it on exit (recording a raised exception on the
+way out); or call `end()` yourself for a span that cannot wrap a block.
+Spans started inside the block nest under it automatically. Always returns
+a usable handle, even when tracing is off, so calling code never branches.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`name` | `str` | A low-cardinality operation name, e.g. `GET /users/:id`. Variable values belong in attributes, not the name. | *required*
+`kind` | `Optional[str]` | `internal` (default), `server`, `client`, `producer` or `consumer`. | `None`
+`attributes` | `Optional[Mapping[str, Any]]` | Initial attributes. | `None`
+`parent` | `Union[Span, str, None]` | A span handle, or an inbound W3C `traceparent` header value to continue a remote trace. Defaults to the active span. | `None`
+`tracestate` | `Optional[str]` | The inbound `tracestate` header accompanying a `traceparent` string `parent`; preserved and propagated. | `None`
+`start_time` | `Union[datetime, float, None]` | A `datetime` or epoch seconds, to backdate the span. | `None`
+
+**Examples:**
+
+```python
+import posthog
+posthog.traces = {"service_name": "checkout-api"}
+
+with posthog.start_span("POST /checkout", parent=request.headers.get("traceparent")) as span:
+    span.set_attribute("plan", user.plan)
+    with posthog.start_span("db.query", kind="client"):
+        ...
+    outgoing_headers = {"traceparent": span.traceparent()}
+```
+
+### `posthog.get_active_span`
+
+```python
+get_active_span() -> Optional[Span]
+```
+
+The span that is active in the current context, or `None`. Alpha.
+
+Only entering a span (`with posthog.start_span(...) as span:`) makes it
+active; a span started manually is not. Use it to propagate the trace to
+the next service: `span.traceparent()` is the header value.
+
+**Examples:**
+
+```python
+span = posthog.get_active_span()
+if span is not None:
+    headers["traceparent"] = span.traceparent()
+```
+
+### `posthog.shutdown`
+
+```python
+shutdown() -> None
+```
+
+Attempt final delivery and permanently shut down the global client.
+
+Call this for final process cleanup, not at the end of each request or
+serverless invocation that shares the module-level client. Use `flush()`
+before returning from those invocations instead. Shutdown closes capture
+lanes, stops background workers and the feature flag poller, and tears down
+integrations. The global client is not recreated automatically after shutdown.
+
+This normally blocks until queued events have been attempted and cleanup
+finishes. Failed or undrainable events may be dropped and reported through
+logging or `on_error`; returning does not guarantee server receipt. Event
+draining has no timeout. Queued spans get a final flush with up to 30 seconds
+waiting for an in-flight flush, then a fresh 30-second drain budget; the last
+HTTP request is not cut short. Unsent queued spans and still-open spans are
+discarded with a warning.
+Lifecycle cleanup is attempted once, and cleanup failures are logged without
+retry. Calls made directly from SDK callbacks such as `on_error` are deferred
+to avoid deadlocking the worker. If blocking completion is required, signal an application-owned
+thread, return from the callback, and call `shutdown()` from that thread.
+Do not wait inside a callback for another thread or task calling a lifecycle
+method.
+
+**Examples:**
+
+```python
+from posthog import shutdown
+shutdown()
+```
+
+### `posthog.setup`
+
+```python
+setup() -> Client
+```
+
+Create or return the global PostHog client configured by module settings.
+
+Most applications should either instantiate `Posthog` directly or set
+`posthog.api_key`/other module settings before calling top-level helpers.
+`setup()` is called automatically by global APIs such as `capture()`.
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Client` | The global `Client` instance. If both `api_key` and `project_api_key` are missing or blank, the client is disabled and module-level calls become no-ops.
+
+## Types
+
+### `OptionalCaptureArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the capture method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the person associated with this event. If not set, the context distinct_id is used, if available, otherwise a UUID is generated, and the event is marked as personless. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to track with the event | 
+`timestamp` |  | When the event occurred (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this specific event. If not provided, one is generated. The event UUID is returned, so you can correlate it with actions in your app (like showing users an error ID if you capture an exception). If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`groups` |  | Group identifiers to associate with this event (format: {group_type: group_key}) | 
+`flags` |  | A `FeatureFlagEvaluations` snapshot from `evaluate_flags()`. The exact flag values from the snapshot are attached to the event with no additional network call — prefer this over `send_feature_flags`. | 
+`send_feature_flags` |  | Deprecated — prefer `flags` with a `FeatureFlagEvaluations` snapshot. Whether to include currently active feature flags in the event properties. Can be a boolean or a SendFeatureFlagsOptions object. Defaults to False. Fires a hidden `/flags` request on capture and may return different values than the ones the code branched on. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this event. Defaults to False. | 
+`options` |  | Capture options for this event, such as `{"process_person_profile": False}`. Sent as given, for PostHog to validate. An option wins over its legacy `$` property, such as `$process_person_profile`. A value that is not a dict is logged and ignored. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`flags` | `NotRequired[Optional[FeatureFlagEvaluations]]` | 
+`groups` | `NotRequired[Optional[Dict[str, str]]]` | 
+`options` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`send_feature_flags` | `NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalCaptureArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.flags`
+
+```python
+flags: NotRequired[Optional[FeatureFlagEvaluations]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.groups`
+
+```python
+groups: NotRequired[Optional[Dict[str, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.options`
+
+```python
+options: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.send_feature_flags`
+
+```python
+send_feature_flags: NotRequired[Optional[Union[bool, SendFeatureFlagsOptions]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalCaptureArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
+
+### `FeatureFlagEvaluations`
+
+```python
+FeatureFlagEvaluations(host: _FeatureFlagEvaluationsHost, distinct_id: str, flags: Dict[str, _EvaluatedFlagRecord], groups: Optional[Mapping[str, Union[str, int]]] = None, disable_geoip: Optional[bool] = None, request_id: Optional[str] = None, evaluated_at: Optional[int] = None, errors_while_computing: bool = False, quota_limited: bool = False, minimal_flag_called_events: bool = False, accessed: Optional[Set[str]] = None, unresolved_flags: Optional[Mapping[str, UnresolvedFlagReason]] = None) -> None
+```
+
+A point-in-time snapshot of feature flag evaluations for a single distinct_id.
+
+Returned by `Client.evaluate_flags` — branch on `is_enabled` /
+`get_flag` and pass the same object to `Client.capture` via the
+`flags` option so the captured event carries the exact flag values the code
+branched on.
+
+```python
+flags = posthog.evaluate_flags(distinct_id, person_properties={"plan": "enterprise"})
+if flags.is_enabled("new-dashboard"):
+    render_new_dashboard()
+posthog.capture("page_viewed", distinct_id=distinct_id, flags=flags)
+```
+
+To narrow the set of flags that get attached to a captured event, use the in-memory
+helpers `only` and `only_accessed`. To narrow the set of flags requested
+from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`get_flag` | Return the flag value. Fires `$feature_flag_called` on first access.
+`get_flag_payload` | Return the payload associated with a flag.
+`is_enabled` | Return whether the flag is enabled. Fires `$feature_flag_called` on the first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+`only` | Return a filtered copy containing only flags with the given keys. Keys that are not present in the evaluation are dropped and logged as a warning.
+`only_accessed` | Return a filtered copy containing only flags accessed via `is_enabled` or `get_flag` before this call.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`keys` | `List[str]` | Return the flag keys that are part of this evaluation.
+`unresolved_flags` | `Mapping[str, UnresolvedFlagReason]` | Return a read-only mapping of flag key to the reason local evaluation left it without a value.
+
+Internal — instances are created by the SDK via `Client.evaluate_flags()`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag`
+
+```python
+get_flag(key: str, *, send_feature_flag_events: bool = True) -> Optional[FlagValue]
+```
+
+Return the flag value. Fires `$feature_flag_called` on first access.
+
+Returns the variant string for multivariate flags, `True` for enabled flags
+without a variant, `False` for disabled flags, and `None` for flags that
+were not returned by the evaluation.
+
+Pass `send_feature_flag_events=False` to skip the event for this read, as
+with `is_enabled`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.get_flag_payload`
+
+```python
+get_flag_payload(key: str) -> Optional[Any]
+```
+
+Return the payload associated with a flag.
+
+Does not count as an access for `only_accessed` and does not fire any event.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.is_enabled`
+
+```python
+is_enabled(key: str, default_value: bool = False, *, send_feature_flag_events: bool = True) -> bool
+```
+
+Return whether the flag is enabled. Fires `$feature_flag_called` on the
+first access per (distinct_id, flag, value) tuple, deduped via the SDK's cache.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The feature flag key. | *required*
+`default_value` | `bool` | Returned when the flag has no value in this evaluation — the key was not part of the evaluated set, or the evaluation itself came back empty (failed `/flags` request, quota limit, or no resolvable `distinct_id`). Defaults to `False`. | `False`
+`send_feature_flag_events` | `bool` | Whether this read sends `$feature_flag_called`. When `False`, no event is sent and the dedupe cache is left alone, but the key still counts as accessed for `only_accessed`. | `True`
+
+A flag that has a value always wins over `default_value`, including a
+disabled flag, which returns `False` even when `default_value=True`.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.keys`
+
+```python
+keys: List[str]
+```
+
+Return the flag keys that are part of this evaluation.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only`
+
+```python
+only(keys: List[str]) -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags with the given keys. Keys that
+are not present in the evaluation are dropped and logged as a warning.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.only_accessed`
+
+```python
+only_accessed() -> FeatureFlagEvaluations
+```
+
+Return a filtered copy containing only flags accessed via `is_enabled`
+or `get_flag` before this call.
+
+Order-dependent: if nothing has been accessed yet, the returned snapshot is
+empty. The method honors its name — pre-access if you want a populated result.
+
+#### `posthog.feature_flag_evaluations.FeatureFlagEvaluations.unresolved_flags`
+
+```python
+unresolved_flags: Mapping[str, UnresolvedFlagReason]
+```
+
+Return a read-only mapping of flag key to the reason local evaluation
+left it without a value.
+
+A flag is listed when it has a loaded local definition, was in the requested
+scope, was inconclusive locally, and no remote value filled the gap. Listed
+flags are not part of `keys`, and reading one reports the
+`local_evaluation_inconclusive` error instead of `flag_missing`. Reading
+this mapping does not count as an access and does not fire any event.
+Snapshots returned by `only` and `only_accessed`, and by
+`AsyncClient.evaluate_flags()`, which evaluates only remotely, carry no
+entries.
+
+### `FeatureFlagResult`
+
+```python
+FeatureFlagResult(key: str, enabled: bool, variant: Optional[str], payload: Optional[Any], reason: Optional[str]) -> None
+```
+
+The result of calling a feature flag which includes the flag result, variant, and payload.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | The unique identifier of the feature flag.
+`enabled` | `bool` | Whether the feature flag is enabled for the current context.
+`variant` | `Optional[str]` | The variant value if the flag is enabled and has variants, None otherwise.
+`payload` | `Optional[Any]` | Additional data associated with the feature flag, if any.
+`reason` | `Optional[str]` | A description of why the flag was enabled or disabled, if available.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_flag_details` | Create a FeatureFlagResult from a FeatureFlag object.
+`from_value_and_payload` | Creates a FeatureFlagResult from a flag value and payload.
+`get_value` | Returns the value of the flag. This is the variant if it exists, otherwise the enabled value. This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+#### `posthog.types.FeatureFlagResult.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlagResult.from_flag_details`
+
+```python
+from_flag_details(details: Union[FeatureFlag, None], override_match_value: Optional[FlagValue] = None) -> FeatureFlagResult | None
+```
+
+Create a FeatureFlagResult from a FeatureFlag object.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`details` | `Union[FeatureFlag, None]` | The FeatureFlag object to convert. | *required*
+`override_match_value` | `Optional[FlagValue]` | If provided, this value will be used to populate the enabled and variant fields instead of the values from the FeatureFlag. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`FeatureFlagResult \| None` | FeatureFlagResult | None: A new FeatureFlagResult instance, or None if details is None.
+
+#### `posthog.types.FeatureFlagResult.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: Union[FlagValue, None], payload: Any) -> Union[FeatureFlagResult, None]
+```
+
+Creates a FeatureFlagResult from a flag value and payload.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`key` | `str` | The unique identifier of the feature flag. | *required*
+`value` | `Union[FlagValue, None]` | The value of the flag (string variant or boolean). | *required*
+`payload` | `Any` | Additional data associated with the feature flag. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`Union[FeatureFlagResult, None]` | Union[FeatureFlagResult, None]: A new FeatureFlagResult instance, or None if value is None.
+
+#### `posthog.types.FeatureFlagResult.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Returns the value of the flag. This is the variant if it exists, otherwise the enabled value.
+This is the value we report as `$feature_flag_response` in the `$feature_flag_called` event.
+
+**Returns:**
+
+Name | Type | Description
+---- | ---- | -----------
+`FlagValue` | `FlagValue` | Either a string variant or boolean value representing the flag's state.
+
+#### `posthog.types.FeatureFlagResult.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlagResult.payload`
+
+```python
+payload: Optional[Any]
+```
+
+#### `posthog.types.FeatureFlagResult.reason`
+
+```python
+reason: Optional[str]
+```
+
+#### `posthog.types.FeatureFlagResult.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FeatureFlag`
+
+```python
+FeatureFlag(key: str, enabled: bool, variant: Optional[str], reason: Optional[FlagReason], metadata: Union[FlagMetadata, LegacyFlagMetadata]) -> None
+```
+
+Detailed feature flag evaluation returned by the flags API.
+
+`enabled`, `variant` and `metadata.payload` are the value rendered the way
+responses before `/flags?v=4` carried it, which the legacy getters return.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`key` | `str` | Feature flag key.
+`enabled` | `bool` | Whether the flag is enabled for the evaluated user or group.
+`variant` | `Optional[str]` | Variant key for multivariate flags, otherwise `None`.
+`reason` | `Optional[FlagReason]` | Optional reason metadata explaining the result.
+`metadata` | `Union[FlagMetadata, LegacyFlagMetadata]` | Payload and other metadata returned by the API.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`from_json` | Parse one flag record of a `/flags` response.
+`from_value_and_payload` | Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+`get_value` | Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.enabled`
+
+```python
+enabled: bool
+```
+
+#### `posthog.types.FeatureFlag.from_json`
+
+```python
+from_json(resp: Any) -> FeatureFlag
+```
+
+Parse one flag record of a `/flags` response.
+
+A record with a `value` member is a `/flags?v=4` record. A record
+without one comes from an older server: its value is `variant`, or
+`enabled` when there is no variant, and its config version is `1`.
+
+#### `posthog.types.FeatureFlag.from_value_and_payload`
+
+```python
+from_value_and_payload(key: str, value: FlagValue, payload: Any) -> FeatureFlag
+```
+
+Build a flag from its value and payload. A string value is a variant, so the flag is enabled.
+
+#### `posthog.types.FeatureFlag.get_value`
+
+```python
+get_value() -> FlagValue
+```
+
+Return the variant for a multivariate flag, otherwise whether the flag is enabled.
+
+#### `posthog.types.FeatureFlag.key`
+
+```python
+key: str
+```
+
+#### `posthog.types.FeatureFlag.metadata`
+
+```python
+metadata: Union[FlagMetadata, LegacyFlagMetadata]
+```
+
+#### `posthog.types.FeatureFlag.reason`
+
+```python
+reason: Optional[FlagReason]
+```
+
+#### `posthog.types.FeatureFlag.variant`
+
+```python
+variant: Optional[str]
+```
+
+### `FlagsAndPayloads`
+
+Bases: `TypedDict`
+
+Feature flag values and payloads keyed by feature flag key.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`featureFlags` | `Optional[dict[str, FlagValue]]` | Each flag's value, keyed by flag key.
+`featureFlagPayloads` | `Optional[dict[str, Any]]` | Each flag's payload, keyed by flag key.
+
+#### `posthog.types.FlagsAndPayloads.featureFlagPayloads`
+
+```python
+featureFlagPayloads: Optional[dict[str, Any]]
+```
+
+#### `posthog.types.FlagsAndPayloads.featureFlags`
+
+```python
+featureFlags: Optional[dict[str, FlagValue]]
+```
+
+### `UnresolvedFlagReason`
+
+Bases: `str`, `Enum`
+
+Why local evaluation left a flag without a value.
+
+Reported by `FeatureFlagEvaluations.unresolved_flags`. Inheriting from
+`str` keeps the members directly comparable to their string values. When more
+than one cause applies, the first reason in the order below is reported.
+
+<details class="values" open markdown="1">
+<summary>Values</summary>
+
+EXPERIENCE_CONTINUITY: The flag has experience continuity enabled, which
+    local evaluation never resolves. Change the flag to fix it.
+UNSUPPORTED_DEFINITION: The flag uses something the local evaluator does not
+    support, such as a static cohort, an unknown operator, a malformed value,
+    a dependency with no loaded definition or a circular dependency. Change
+    the flag or upgrade the SDK to fix it.
+UNRESOLVED_DEPENDENCY: A flag this flag depends on has a loaded definition
+    but was unresolved.
+MISSING_CONTEXT: The call did not pass a property, group property or device
+    id the flag needs, or passed it in an unusable form. Pass it to fix it.
+
+</details>
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`EXPERIENCE_CONTINUITY` |  | 
+`MISSING_CONTEXT` |  | 
+`UNRESOLVED_DEPENDENCY` |  | 
+`UNSUPPORTED_DEFINITION` |  | 
+
+#### `posthog.types.UnresolvedFlagReason.EXPERIENCE_CONTINUITY`
+
+```python
+EXPERIENCE_CONTINUITY = 'experience_continuity'
+```
+
+#### `posthog.types.UnresolvedFlagReason.MISSING_CONTEXT`
+
+```python
+MISSING_CONTEXT = 'missing_context'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNRESOLVED_DEPENDENCY`
+
+```python
+UNRESOLVED_DEPENDENCY = 'unresolved_dependency'
+```
+
+#### `posthog.types.UnresolvedFlagReason.UNSUPPORTED_DEFINITION`
+
+```python
+UNSUPPORTED_DEFINITION = 'unsupported_definition'
+```
+
+### `InconclusiveMatchError`
+
+```python
+InconclusiveMatchError(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when local evaluation can't determine a flag's value. `reason` says
+why, as reported by `FeatureFlagEvaluations.unresolved_flags`.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why local evaluation couldn't resolve the flag.
+
+#### `posthog.feature_flags.InconclusiveMatchError.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `RequiresServerEvaluation`
+
+```python
+RequiresServerEvaluation(*args, reason: Optional[UnresolvedFlagReason] = None)
+```
+
+Bases: `Exception`
+
+Raised when feature flag evaluation requires server-side data that is not
+available locally (e.g., static cohorts).
+
+This error should propagate immediately to trigger API fallback, unlike
+InconclusiveMatchError which allows trying other conditions.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`reason` | `UnresolvedFlagReason` | Why the flag needs server-side evaluation.
+
+#### `posthog.feature_flags.RequiresServerEvaluation.reason`
+
+```python
+reason: UnresolvedFlagReason = UnresolvedFlagReason.UNSUPPORTED_DEFINITION
+```
+
+### `CaptureError`
+
+```python
+CaptureError(status: int | str, message: str, *, endpoint: str, retry_after: Optional[float] = None, request_id: Optional[str] = None, attempts: Optional[int] = None, retry_exhausted: Optional[list[str]] = None, drops: Optional[list[tuple[str, Optional[str]]]] = None, event_results: Optional[dict[str, CaptureEventResult]] = None)
+```
+
+Bases: `APIError`
+
+A capture batch that was not fully delivered.
+
+Passed to `on_error` with the batch. `status` is the HTTP status of the
+last attempt, or `0` when no response arrived (`__cause__` holds the
+transport error). A 2xx `status` means the request succeeded but some
+events were dropped or ran out of retries.
+
+`event_results` maps each event uuid to its last verdict from a 2xx
+response. Events missing from it never got a verdict, because every
+attempt that reached them failed as a whole request.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`verdict_summary` | Count the undelivered events by verdict and reason, for example `drop/llm_events_over_quota=2, retry/not_persisted=1`.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`attempts` |  | 
+`drops` |  | 
+`endpoint` |  | 
+`event_results` |  | 
+`message` |  | 
+`request_id` |  | 
+`retry_after` |  | 
+`retry_exhausted` |  | 
+`status` |  | 
+
+#### `posthog.capture_send.CaptureError.attempts`
+
+```python
+attempts = attempts
+```
+
+#### `posthog.capture_send.CaptureError.drops`
+
+```python
+drops = drops or []
+```
+
+#### `posthog.capture_send.CaptureError.endpoint`
+
+```python
+endpoint = endpoint
+```
+
+#### `posthog.capture_send.CaptureError.event_results`
+
+```python
+event_results = event_results or {}
+```
+
+#### `posthog.capture_send.CaptureError.message`
+
+```python
+message = message
+```
+
+#### `posthog.capture_send.CaptureError.request_id`
+
+```python
+request_id = request_id
+```
+
+#### `posthog.capture_send.CaptureError.retry_after`
+
+```python
+retry_after = retry_after
+```
+
+#### `posthog.capture_send.CaptureError.retry_exhausted`
+
+```python
+retry_exhausted = retry_exhausted or []
+```
+
+#### `posthog.capture_send.CaptureError.status`
+
+```python
+status = status
+```
+
+#### `posthog.capture_send.CaptureError.verdict_summary`
+
+```python
+verdict_summary() -> str
+```
+
+Count the undelivered events by verdict and reason, for example
+`drop/llm_events_over_quota=2, retry/not_persisted=1`.
+
+Counts the events in `drops` and `retry_exhausted`: events the
+server dropped, and events still pending retry after the last 2xx
+response. A retry verdict followed by a failed request, for example a
+503 on the last attempt, is not counted; `event_results` keeps it.
+Empty when no event is counted.
+
+### `Span`
+
+A handle to a span.
+
+Every method is safe to call on any handle, including after `end()` and
+on the inert handles returned when tracing is off, so calling code never
+branches on whether tracing is running. Entering a handle (`with span:`)
+makes it the active span for the block and ends it on exit, recording an
+`Exception` raised inside it. A `BaseException` that is not an
+`Exception` (`GeneratorExit`, `CancelledError`, `KeyboardInterrupt`)
+still ends the span but is not recorded as a failure.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`add_event` | Add a timestamped event to the span. Ignored after `end()`.
+`end` | End the span and queue it for export. Idempotent.
+`record_exception` | Record an exception as an `exception` event and mark the span `error`.
+`set_attribute` | Set one attribute on the span; last write wins. Ignored after `end()`.
+`set_attributes` | Set several attributes at once; last write wins per key. Ignored after `end()`.
+`set_status` | Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+`traceparent` | The W3C `traceparent` header value to propagate, or `None`.
+`tracestate` | The W3C `tracestate` header value to propagate, or `None`.
+`update_name` | Rename the span, for a name only known after it started. Ignored after `end()`.
+
+#### `posthog.tracing.span.Span.add_event`
+
+```python
+add_event(name: str, attributes: Optional[Mapping[str, Any]] = None, timestamp: Union[datetime, float, None] = None) -> Span
+```
+
+Add a timestamped event to the span. Ignored after `end()`.
+
+`timestamp` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`. Returns the span, so calls
+chain.
+
+**Examples:**
+
+```python
+span.add_event("cache.miss", {"key": "user:42"})
+```
+
+#### `posthog.tracing.span.Span.end`
+
+```python
+end(end_time: Union[datetime, float, None] = None) -> None
+```
+
+End the span and queue it for export. Idempotent.
+
+`end_time` defaults to now; it accepts a `datetime`, or seconds
+since the epoch as a `float` or `int`, and is never earlier than
+the start. Later calls, and later mutations, no-op. `with span:`
+ends the span on exit, so call this only for spans started manually.
+
+**Examples:**
+
+```python
+span = posthog.start_span("job")
+try:
+    run_job()
+finally:
+    span.end()
+```
+
+#### `posthog.tracing.span.Span.record_exception`
+
+```python
+record_exception(exception: BaseException) -> Span
+```
+
+Record an exception as an `exception` event and mark the span `error`.
+
+Ignored after `end()`. The event carries `exception.type`,
+`exception.message` and, for a raised exception,
+`exception.stacktrace` (its last `max_attribute_value_length`
+characters, so a chained traceback keeps the outermost exception and
+may lose its cause). Returns the span, so calls chain. Inside
+`with span:` a raised `Exception` is recorded automatically, so
+this is for exceptions that are caught and handled.
+
+**Examples:**
+
+```python
+try:
+    charge(card)
+except PaymentError as e:
+    span.record_exception(e)
+```
+
+#### `posthog.tracing.span.Span.set_attribute`
+
+```python
+set_attribute(key: str, value: Any) -> Span
+```
+
+Set one attribute on the span; last write wins. Ignored after `end()`.
+
+Returns the span, so calls chain. Prefer primitive values: strings,
+booleans, integers and floats keep their type. Lists and mappings are
+sent as OTLP arrays and maps, but PostHog stores them as serialized
+strings. `None` removes the key; anything else is stringified.
+
+**Examples:**
+
+```python
+span.set_attribute("http.status_code", 200).set_attribute("cache.hit", True)
+```
+
+#### `posthog.tracing.span.Span.set_attributes`
+
+```python
+set_attributes(attributes: Mapping[str, Any]) -> Span
+```
+
+Set several attributes at once; last write wins per key. Ignored after `end()`.
+
+Returns the span, so calls chain. Same encoding as `set_attribute()`.
+
+**Examples:**
+
+```python
+span.set_attributes({"db.system": "postgresql", "db.rows": 12})
+```
+
+#### `posthog.tracing.span.Span.set_status`
+
+```python
+set_status(code: str, message: Optional[str] = None) -> Span
+```
+
+Set the span status to `"ok"` or `"error"`. Ignored after `end()`.
+
+Unset by default. Any other `code` is ignored. `ok` is final for the
+scoped form: an `Exception` raised inside `with span:` does not override
+it. Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span.set_status("error", "upstream timed out")
+```
+
+#### `posthog.tracing.span.Span.traceparent`
+
+```python
+traceparent() -> Optional[str]
+```
+
+The W3C `traceparent` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.tracestate`
+
+```python
+tracestate() -> Optional[str]
+```
+
+The W3C `tracestate` header value to propagate, or `None`.
+
+#### `posthog.tracing.span.Span.update_name`
+
+```python
+update_name(name: str) -> Span
+```
+
+Rename the span, for a name only known after it started. Ignored after `end()`.
+
+Returns the span, so calls chain.
+
+**Examples:**
+
+```python
+span = posthog.start_span("http.request")
+span.update_name(f"{request.method} {route.pattern}")
+```
+
+### `Emails`
+
+```python
+Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None) -> None
+```
+
+Bases: `_EmailsBase`
+
+Sends transactional email from PostHog email templates.
+
+`host` is your PostHog app host. PostHog Cloud ingestion hosts map to the
+app host, so `us.i.posthog.com` sends to `us.posthog.com`. Any other
+host is used as given.
+
+Each send retries network errors, rate limits and an unavailable service up
+to `max_retries` times, with the same idempotency key. Set
+`max_retries=0` when a job runner already retries the send. `timeout`
+is in seconds, per request. Pass `session` to send through your own
+`requests.Session`, for example a test double.
+
+**Functions:**
+
+Name | Description
+---- | -----------
+`close` | Close the HTTP connections this client opened. A `session` you passed in stays open.
+`get` | Read what happened to an email that `send` queued.
+`send` | Queue one email from a transactional email template.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disabled` |  | 
+`host` |  | 
+`max_retries` |  | 
+`secret_key` |  | 
+`timeout` |  | 
+
+#### `posthog.emails.Emails.close`
+
+```python
+close() -> None
+```
+
+Close the HTTP connections this client opened. A `session` you passed in stays open.
+
+#### `posthog.emails.Emails.disabled`
+
+```python
+disabled = disabled
+```
+
+#### `posthog.emails.Emails.get`
+
+```python
+get(message_id: Union[str, UUID]) -> EmailStatus
+```
+
+Read what happened to an email that `send` queued.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`message_id` | `Union[str, UUID]` | The `id` of the `SendEmailResult` that `send` returned. | *required*
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`EmailStatus` | The email's latest status, for 30 days after the send.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not answer with a status. `code` is `not_found` for an unknown ID, an email older than 30 days, or for a few seconds after the send.
+`ValueError` | `message_id` is not a message ID.
+
+**Examples:**
+
+```python
+result = emails.send(to="user@example.com", template_id="...")
+status = emails.get(result.id)
+if status.status == "bounced":
+    print(status.reason)
+```
+
+#### `posthog.emails.Emails.host`
+
+```python
+host = determine_app_host(host)
+```
+
+#### `posthog.emails.Emails.max_retries`
+
+```python
+max_retries = max_retries
+```
+
+#### `posthog.emails.Emails.secret_key`
+
+```python
+secret_key = secret_key.strip() if isinstance(secret_key, str) else None
+```
+
+#### `posthog.emails.Emails.send`
+
+```python
+send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
+```
+
+Queue one email from a transactional email template.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` | `str` | One recipient email address. | *required*
+`template_id` | `Union[str, UUID]` | The UUID of a template made transactional in PostHog. | *required*
+`template_data` | `Optional[Mapping[str, Any]]` | Values for the template's `{{ variables.* }}` placeholders. Values are encoded the way capture encodes properties. | `None`
+`distinct_id` | `Optional[str]` | The recipient's distinct ID in your product. The email's events go to this person. Without it, they go to a person whose distinct ID is the email address. | `None`
+`idempotency_key` | `Optional[str]` | 1 to 255 visible ASCII characters. A send with a key that PostHog has already accepted queues nothing and returns the first send's result. Without it, the client makes a key that covers its own retries. Pass a key derived from what the email is for, such as `welcome:user_123`, to cover retries outside this call, too. | `None`
+`max_retries` | `Optional[int]` | Overrides the client's maximum number of retries for this send. `0` turns retries off. | `None`
+
+**Returns:**
+
+Type | Description
+---- | -----------
+`SendEmailResult` | The queued email. A result means PostHog queued the email, not that it was delivered.
+
+**Raises:**
+
+Type | Description
+---- | -----------
+`EmailError` | PostHog did not queue the email, or the client could not tell whether it did.
+`(TypeError, ValueError)` | An argument has the wrong type or format.
+
+**Examples:**
+
+```python
+emails.send(
+    to="user@example.com",
+    template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+    template_data={"name": "Ada"},
+    distinct_id="user_123",
+    idempotency_key="welcome:user_123",
+)
+```
+
+#### `posthog.emails.Emails.timeout`
+
+```python
+timeout = timeout
+```
+
+### `EmailError`
+
+```python
+EmailError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None) -> None
+```
+
+Bases: `Exception`
+
+PostHog did not queue the email, or the client could not tell whether it did.
+
+Branch on `code`, PostHog's stable error code, or on `name`, a coarse
+category of the failure. The message never contains the secret key or the
+request body.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`name` |  | A coarse category of the failure.
+`code` |  | PostHog's stable error code.
+`message` |  | What went wrong. It never contains the secret key or the request body.
+`status_code` |  | The HTTP status of the response, or `None` when none arrived.
+`why` |  | PostHog's explanation of the failure, when it gave one.
+`fix` |  | What to change to fix it, when PostHog said.
+`docs_url` |  | A docs page about the error, when PostHog gave one.
+`field` |  | The request field the error is about, when there is one.
+`retry_after` |  | Seconds to wait before retrying, when PostHog said.
+
+#### `posthog.emails.EmailError.code`
+
+```python
+code = code
+```
+
+#### `posthog.emails.EmailError.docs_url`
+
+```python
+docs_url = docs_url
+```
+
+#### `posthog.emails.EmailError.field`
+
+```python
+field = field
+```
+
+#### `posthog.emails.EmailError.fix`
+
+```python
+fix = fix
+```
+
+#### `posthog.emails.EmailError.message`
+
+```python
+message = message
+```
+
+#### `posthog.emails.EmailError.name`
+
+```python
+name = name
+```
+
+#### `posthog.emails.EmailError.retry_after`
+
+```python
+retry_after = retry_after
+```
+
+#### `posthog.emails.EmailError.status_code`
+
+```python
+status_code = status_code
+```
+
+#### `posthog.emails.EmailError.why`
+
+```python
+why = why
+```
+
+### `SendEmailResult`
+
+```python
+SendEmailResult(id: str, replayed: bool = False, warnings: tuple[EmailWarning, ...] = ()) -> None
+```
+
+The queued email. `id` is its message ID.
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`id` | `str` | The email's message ID.
+`replayed` | `bool` | `True` when the response says PostHog replayed an earlier send for the same `idempotency_key` instead of sending again.
+`warnings` | `tuple[EmailWarning, ...]` | Warnings PostHog returned about the request.
+
+#### `posthog.emails.SendEmailResult.id`
+
+```python
+id: str
+```
+
+#### `posthog.emails.SendEmailResult.replayed`
+
+```python
+replayed: bool = False
+```
+
+#### `posthog.emails.SendEmailResult.warnings`
+
+```python
+warnings: tuple[EmailWarning, ...] = ()
+```
+
+### `OptionalSetArgs`
+
+Bases: `TypedDict`
+
+Optional arguments for the set method.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`distinct_id` |  | Unique identifier for the user to set properties on. If not set, the context distinct_id is used, if available, otherwise this function does nothing. Setting context-level distinct_id's is recommended. | 
+`properties` |  | Dictionary of properties to set on the person | 
+`timestamp` |  | When the properties were set (defaults to current time). UTC is preferred; non-UTC datetimes and parseable ISO timestamp strings are converted to UTC. | 
+`uuid` |  | Unique identifier for this operation. If not provided, one is generated. This UUID is returned, so you can correlate it with actions in your app. If provided, it must be a valid UUID string or uuid.UUID instance; invalid values are ignored and replaced with a newly generated UUID. | 
+`disable_geoip` |  | Whether to disable GeoIP lookup for this operation. Defaults to False. | 
+`options` |  | Capture options for this event, sent as given. See `OptionalCaptureArgs`. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`disable_geoip` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[ID_TYPES]]` | 
+`options` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`properties` | `NotRequired[Optional[Dict[str, Any]]]` | 
+`timestamp` | `NotRequired[Optional[Union[datetime, str]]]` | 
+`uuid` | `NotRequired[Optional[Union[str, UUID]]]` | 
+
+#### `posthog.args.OptionalSetArgs.disable_geoip`
+
+```python
+disable_geoip: NotRequired[Optional[bool]]
+```
+
+#### `posthog.args.OptionalSetArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[ID_TYPES]]
+```
+
+#### `posthog.args.OptionalSetArgs.options`
+
+```python
+options: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalSetArgs.properties`
+
+```python
+properties: NotRequired[Optional[Dict[str, Any]]]
+```
+
+#### `posthog.args.OptionalSetArgs.timestamp`
+
+```python
+timestamp: NotRequired[Optional[Union[datetime, str]]]
+```
+
+#### `posthog.args.OptionalSetArgs.uuid`
+
+```python
+uuid: NotRequired[Optional[Union[str, UUID]]]
+```
diff --git a/references/posthog-python-migration.md b/references/posthog-python-migration.md
new file mode 100644
index 000000000..1c6c18564
--- /dev/null
+++ b/references/posthog-python-migration.md
@@ -0,0 +1,269 @@
+---
+title: PostHog Python SDK migration guides
+sidebar: Docs
+showTitle: true
+---
+
+# Migrating from posthog 7.x to 8.0
+
+posthog 8.0 sends every event through capture v1 and removes the legacy capture path.
+Most apps upgrade without code changes.
+Read the checklist first, then the sections that apply to you.
+
+For the changes every capture v1 SDK shares, such as event options, limits and per-event results, see [Upgrading to capture v1 SDKs](https://posthog.com/docs/libraries/capture-v1).
+
+## Checklist
+
+You need to change code if your app does any of these:
+
+- passes `Client` or `AsyncPosthog` constructor arguments by position after `host`
+- calls `posthog.request.post` or `posthog.request.flags` with positional arguments after `path` or `host`
+- sets `$exception_level` or another reserved exception property in `capture_exception(properties=...)`
+- sets `capture_mode`, `POSTHOG_CAPTURE_MODE` or `gzip`
+- imports `CaptureMode`, `posthog.capture_mode`, `CaptureV1Error`, `posthog.capture_v1`, `request.batch_post`, `EVENTS_ENDPOINT` or `AI_EVENTS_ENDPOINT`
+- sends events to a self-hosted PostHog that does not serve the capture v1 endpoints
+- sends events through a proxy that redirects capture requests to another host
+- reuses one event `uuid` for more than one event
+- sets `$process_person_profile` to turn person processing on for events without a distinct ID
+- passes strings such as `"true"` for `$cookieless_mode`, `$ignore_sent_at` or `$process_person_profile`
+- expects `super_properties` to override properties passed to a single call, including `$set` and `$groups`
+- sets `$is_server`, `$geoip_disable` or a system property such as `$os` and expects the SDK's value to win
+- tests the AI integrations with a mock client and asserts on `capture`
+- passes its own client object to the AI integrations
+- sets `$lib` or `$lib_version`, or filters on `$lib = "posthog-python-mcp"`
+- passes a personal API key (`phx_...`) as the project API key
+- reads event content from the SDK's debug log
+- calls `alias()` without a `distinct_id` and relies on the context distinct ID
+- runs the Django, Flask or ASGI integration on 7.68 to 7.70 without tracing headers turned on (they are now read by default)
+
+## Endpoints
+
+| Method | Endpoint |
+| --- | --- |
+| `capture`, `set`, `set_once`, `alias`, `group_identify`, `capture_exception` | `/i/v1/analytics/events` |
+| `capture_ai`, `capture_ai_immediate`, and the AI wrapper integrations | `/i/v1/ai/events` |
+| OpenTelemetry (`posthog.ai.otel`) | `/i/v0/ai/otel`, unchanged |
+
+If you send events to a self-hosted PostHog, check that it serves both endpoints before you upgrade.
+An endpoint that is not served drops every event sent to it.
+
+If you send events through your own reverse proxy, update it before you upgrade:
+
+- Forward `/i/v1/analytics/events` and `/i/v1/ai/events` to PostHog.
+- Pass `Authorization` (the project token, sent as `Bearer <token>`), every `PostHog-*` header, `Content-Type`, `Content-Encoding` and `User-Agent` through unchanged. PostHog answers `401` without `Authorization` and `400` without the others, and the batch fails.
+- Accept request bodies up to 20 MB. AI requests are often larger than 1 MB, the default limit in nginx and ingress-nginx. A `413` from the proxy fails the batch.
+
+PostHog's managed reverse proxy already does this. See the [proxy guides](https://posthog.com/docs/advanced/proxy).
+
+The SDK follows a `307` or `308` redirect only to the origin of `host` (same scheme, host and port), at most 5 times.
+Any other redirect fails the batch and reaches `on_error`.
+In 7.x the sync client followed redirects to any origin.
+If a proxy redirects capture requests to another host, point `host` at the final host.
+
+## SDK identity
+
+PostHog sets `$lib` and `$lib_version` on every event from the `PostHog-Sdk-Info` request header, which is always `posthog-python/<version>`.
+The SDK removes `$lib` and `$lib_version` from the properties it sends.
+A value you set in a call, in `super_properties` or in `before_send` does not reach PostHog.
+
+MCP instrumentation no longer relabels the client.
+In 7.x, `posthog.mcp.instrument()` and `PostHogMCP` set the client's identity to `posthog-python-mcp`.
+With the default client, or any client the app also used, every event and feature flag request from the app then reported `posthog-python-mcp`, not only the MCP events.
+In 8.0, MCP events report `posthog-python` like all other events.
+To find MCP traffic, filter on the `$mcp_*` events and properties instead of `$lib`.
+
+## Removed options and APIs
+
+| Removed | Use instead |
+| --- | --- |
+| `capture_mode`, `CaptureMode`, `POSTHOG_CAPTURE_MODE` | Nothing. Capture v1 is the only path. Setting `posthog.capture_mode` on the module has no effect. |
+| `gzip=True` | `capture_compression=CaptureCompression.GZIP`. The default is no compression. `POSTHOG_CAPTURE_COMPRESSION` still works. |
+| `CaptureV1Error` (`from posthog.capture_v1 import CaptureV1Error`) | `CaptureError` (`from posthog import CaptureError`). There is no alias. |
+| `posthog.capture_v1` | `posthog.capture_event` and `posthog.capture_send` |
+| `request.batch_post`, `async_batch_post`, `EVENTS_ENDPOINT`, `AI_EVENTS_ENDPOINT` | Nothing. Send events through a client. |
+| The `gzip` parameter of `request.post` and `request.flags` | Nothing. The parameters after `path` in `post` and after `host` in `flags` are keyword-only, so a 7.x call that passes them by position raises `TypeError`. A `gzip=` keyword raises no error: it is sent as a field in the request body. |
+| The `backoff` dependency | Add it to your own requirements if your code imports it. |
+
+The `posthoganalytics` package has the same changes. For example, import `CaptureError` from `posthoganalytics`.
+
+Constructor arguments after `host` are keyword-only:
+
+```python
+# 7.x
+Posthog("<api_key>", "https://us.i.posthog.com", True)
+
+# 8.0
+Posthog("<api_key>", host="https://us.i.posthog.com", debug=True)
+```
+
+## Errors and `on_error`
+
+Capture v1 returns a result for every event, even when the request succeeds.
+An event can be dropped inside a 2xx response, for example when it is over a product quota.
+8.0 reports those events as failures.
+When the whole request is over the billing limit, capture returns a `402` with no per-event results instead.
+
+- Every capture failure is a `CaptureError`, a subclass of `APIError`. It has these fields:
+  - `status`: the HTTP status, or `0` when the request never got a response. With `0`, `__cause__` holds the network error. In 7.x, `on_error` received the raw `requests` exception.
+  - `endpoint`, `request_id` and `attempts`
+  - `drops`: `(uuid, details)` pairs for the events capture dropped in a 2xx response
+  - `retry_exhausted`: the uuids still waiting for a retry after the last attempt
+  - `event_results`: a `CaptureEventResult(result, details)` for each uuid that got a result in a 2xx response, from `posthog.capture_send`. An event missing from it never got a result.
+  - `verdict_summary()`: counts such as `drop/llm_events_over_quota=1, retry/not_persisted=1`
+- `on_error(error, batch)` receives every failure, including in `sync_mode` and from `AsyncPosthog.capture_immediate`.
+- With `on_error` set, the SDK logs nothing for a failed batch.
+- Without `on_error`, the SDK logs one line per failed batch, for example `2 event(s) not persisted by /i/v1/analytics/events: ...`. The line never contains event content or the server's response text. After a 2xx response it also counts the lost events by PostHog's reason, for example `drop/event_too_big=1`.
+- The 7.x lines `error uploading: ...`, `async capture upload failed (...)` and `Immediate async capture failed (...)` are gone. In `sync_mode`, a failed request no longer logs the 7.x `Error in capture: ...` line, or the same line for another method. Update any log-based alerts that match these lines.
+- In `sync_mode`, a failed `capture()` calls `on_error` and returns `None`. With `debug=True` it calls `on_error` and then re-raises the error.
+- In `sync_mode`, a failed request is retried like a background batch, in the calling thread. With the default `max_retries` of 3, a call makes up to 4 attempts, and each attempt can take up to `timeout` (`capture_ai_timeout` for AI events). With the defaults, an analytics event whose requests keep timing out blocks the call for about a minute. 7.x made one attempt.
+- If a capture inside `on_error` fails, the SDK logs the failure and does not call `on_error` again.
+- The SDK retries `404`, `408`, `429`, `500`, `502`, `503` and `504` responses and network errors. Other error statuses fail the batch at once, including the other 5xx codes. 7.x retried `429` and every 5xx, but not `404`. Capture itself does not return `429`; a proxy in front of it can. A `404` that lasts through every attempt can mean the PostHog deployment has no capture v1 route, for example an older self-hosted install.
+- Each attempt makes one connection try. 7.x also retried a failed connection up to twice inside each attempt, so a capture request could block for up to three times the `timeout` per attempt.
+- Retries start at 100 ms and double each attempt, up to 30 seconds. Each wait varies randomly by up to 25%, so many clients do not retry at the same moment. A `Retry-After` header sets a minimum wait, up to 30 seconds. The `Consumer` default is 3 retries, down from 10. In 7.x the first retry waited up to 1 second.
+- The SDK's own log lines no longer contain event content: the debug line for a queued event names the event and the lane, and the invalid timestamp warning no longer includes the value. When your `before_send` hook raises, the error line names the event and the exception type, not the exception message, which can hold the data the hook was removing. The traceback is logged at debug level. To inspect events, use `before_send`.
+- A personal API key (`phx_...`) passed as the project API key disables the client and logs one error, as an empty key does. Capture rejects personal API keys, and the SDK no longer sends one with every request.
+
+## Invalid events
+
+Capture rejects a whole batch when one event cannot be parsed.
+8.0 drops only the invalid event, so the rest of the batch is delivered.
+
+- An event whose name is missing, `None`, empty or not a string is dropped. The SDK logs one warning per reason per process. 7.x sent it.
+- An event whose `before_send` hook sets `distinct_id` to `None` or a non-string is dropped, with one warning per reason per process. The SDK does not convert the hook's value or make up an ID. 7.x sent it, and capture would reject the whole batch.
+- PostHog drops an event whose name is over 200 UTF-8 bytes (`event_name_too_long`), and `on_error` reports it. 7.x sent events to legacy capture, which had no event name limit.
+- A `NaN` or infinite `float` value is sent as `null`, as in 7.75 and later, and the event is kept. Earlier 7.x versions sent invalid JSON, which made capture reject the whole batch. A `NaN` value in `$set` sets that person property to `null`.
+- An event that cannot be serialized to JSON, for example one with a circular reference, is dropped and logged. As in 7.x, a circular reference logs `Error in capture: maximum recursion depth exceeded` with a long traceback.
+- A property or option key that JSON cannot represent, such as a tuple, is dropped without a log, and the rest of the event is sent. 7.x dropped the event. `int`, finite `float`, `bool` and `None` keys are still converted to strings. A `NaN` or infinite `float` key still drops the event.
+
+## Event uuids
+
+- Each event needs its own uuid. Capture keeps the first event for each uuid in a request and drops the later copies. `on_error` reports each dropped copy in `CaptureError.drops` as `(uuid, "duplicate_event_uuid")`. 7.x sent every copy. Older PostHog versions reject the whole batch with a 400 `duplicate_event_uuid` instead.
+- The SDK accepts a uuid with hyphens, 32 hex digits, `{...}` braces or a `urn:uuid:` prefix, in any case. It sends the lowercase hyphenated form and returns that form from `capture`.
+- Any other value is replaced with a generated uuid, and the SDK logs one warning that names the rule, not the value. An empty string counts as unset, so the SDK generates a uuid without a warning. This applies to `AsyncPosthog` too.
+- Generated uuids are UUIDv7.
+
+## Session and window IDs
+
+Capture v1 sends `$session_id` and `$window_id` as top-level event fields, not as properties.
+The SDK moves them out of `properties` for you.
+
+- A string is sent as given, including `""`.
+- `None` counts as unset and is removed.
+- Any other value is removed and not sent, because capture would reject the whole batch. 7.x sent it as a property. The SDK logs a warning for each one, with the key and the value's type but not the value.
+
+## Identity and request context
+
+- An empty or whitespace-only `distinct_id` counts as missing, so the event gets a generated personless distinct ID. 7.x sent a whitespace-only ID, and capture dropped the event.
+- Generated personless distinct IDs are UUIDv7. 7.x generated UUIDv4.
+- `group_identify` uses the `distinct_id` you pass, then the context distinct ID, then `$<group_type>_<group_key>`. 7.x fell back to a random ID, which created a new person on every call. If `$<group_type>_<group_key>` is over 200 bytes, pass `distinct_id`: PostHog drops an event whose distinct ID is over 200 bytes.
+- PostHog drops an event whose `distinct_id` is over 200 UTF-8 bytes (`distinct_id_too_large`), and `on_error` reports it. 7.x sent events to legacy capture, which shortened the ID to 200 characters and kept the event.
+- `group_identify` no longer adds the context session ID. A session takes the person of its latest event, and this event's distinct ID is not the session's user.
+- `alias()` needs an explicit `distinct_id`. It no longer falls back to the context distinct ID, which can come from a request header the client controls. Without one, the call is dropped with a warning.
+- Context tags and context options now apply to `alias` and `group_identify`, below the call's own values, as they do for `capture`.
+- Person processing turned off in the context, with `set_context_option("process_person_profile", False)` or a `$process_person_profile` tag, or in `super_options`, now applies to `$create_alias` and `$groupidentify` events too. A `$process_person_profile: False` in `super_properties` already did this in 7.x. PostHog drops these events when person processing is off, with an ingestion warning. Capture accepts them, so `on_error` does not report the drop. To keep them, turn person processing off per call instead.
+
+## Tracing headers
+
+The Django, Flask and ASGI integrations read the `X-PostHog-Distinct-Id` and `X-PostHog-Session-Id` headers by default, as in 7.71 and later.
+The headers only fill a missing distinct ID or session ID, and any client can set them, so never use them for authentication.
+
+- To turn this off, set `POSTHOG_MW_CAPTURE_TRACING_HEADERS = False` in Django, or pass `capture_tracing_headers=False` to the Flask or ASGI integration.
+- The 7.68 `trust_tracing_headers` and `POSTHOG_MW_TRUST_TRACING_HEADERS` names still work, but are deprecated.
+- If you upgrade from 7.68, 7.69 or 7.70 and never turned these headers on, they are now read.
+
+## Exceptions
+
+- `capture_exception` takes a `level=` argument on `Client`, `AsyncPosthog` and the module. It sets `$exception_level`, for example `"warning"` or `"fatal"`. The default is `"error"`, and an unknown value counts as unset.
+- `capture_exception` ignores reserved exception properties in `properties`, such as `$exception_list`, `$exception_level` and `$exception_source`. In 7.x they overrode the SDK's values, with a `DeprecationWarning`. Use `level=` instead of `$exception_level`.
+- `AsyncPosthog.capture_exception` now sends `$exception_level`.
+- `AsyncPosthog.capture_exception` now adds `$trace_id` and `$span_id` from the active OpenTelemetry span, like `Client.capture_exception`. In 7.x it added them only with `capture_trace_context=True`.
+
+## Event options
+
+Capture v1 sends processing options in an `options` object, next to `properties`.
+
+- `capture`, `capture_ai`, `set`, `set_once`, `alias`, `group_identify` and `capture_exception` take an `options` argument:
+
+  ```python
+  posthog.capture("signed_up", distinct_id="user-1", options={"cookieless_mode": True})
+  ```
+
+- `super_options`, a new `Client`, `AsyncPosthog` and module setting, sets options on every event, like `super_properties`.
+- `set_context_option(key, value)` sets an option for the current context, like `tag()`. `get_context_options()` returns the options of the current context. Both exist on `Client` and as module functions. `AsyncPosthog` has no context methods, like it has no `tag()`, so call the module functions. They apply to every client in the context.
+- Context tags and options reach `capture`, `capture_ai`, `capture_exception`, `alias` and `group_identify`. Context options also reach `set` and `set_once`. `super_properties` and `super_options` reach every method.
+- Options are sent as given. PostHog validates them. It drops an event with an option value it cannot read, such as a list for `cookieless_mode`, as `invalid_options`, and `on_error` reports it.
+- An `options` value that is not a dict is logged as an error and ignored. The event is still sent.
+- The legacy option properties, the `$`-prefixed properties legacy capture reads as settings, still work. They fill the matching option only when it is unset, and the SDK always removes them from `properties`. Their values are no longer converted, so pass `True` or `False`, not `"true"`.
+
+  | Legacy option property | Option |
+  | --- | --- |
+  | `$cookieless_mode` | `cookieless_mode` |
+  | `$ignore_sent_at` | `disable_skew_correction` |
+  | `$product_tour_id` | `product_tour_id` |
+  | `$process_person_profile` | `process_person_profile` |
+
+- An option set at any layer wins over its legacy property set at any layer. For example, `super_options={"cookieless_mode": True}` wins over an event's `$cookieless_mode: False`. When you move a default to options, move the per-event overrides of that key to options too.
+- A `None` option counts as unset, so a later step can fill it.
+
+Values apply in this order. Steps 2 to 4 fill only the options and properties that the steps before them left unset:
+
+1. the `options` and `properties` of the call, then the call's `disable_geoip` argument, which fills `$geoip_disable`
+2. context options and tags
+3. `super_options` and `super_properties`
+4. values the SDK sets: `$is_server` from `is_server`, `$geoip_disable` from the client's `disable_geoip` setting, system properties such as `$os` and `$python_version`, the `$feature/<key>` and `$active_feature_flags` properties from `flags` or `send_feature_flags`, `$trace_id` and `$span_id` from the active OpenTelemetry span (in `capture` and `capture_ai` only with `capture_trace_context=True`, and always in `capture_exception`), `options.process_person_profile = false` for events without a distinct ID, and `$release_id` from `POSTHOG_RELEASE_ID`
+5. `before_send`, which sees the result of steps 1 to 4 and can change or remove any of it
+6. legacy properties, which fill unset options and are then removed
+
+A property set to `None` counts as set, so no later step fills it.
+`$set`, `$set_once`, `$groups` and `$group_set` fill one level deep.
+When the call and a later step both set one of them to a dict, the later step adds only the keys the call left out.
+For example, `super_properties={"$set": {"plan": "free", "source": "web"}}` and a call with `properties={"$set": {"plan": "pro"}}` send `{"plan": "pro", "source": "web"}`.
+
+These changes follow from this order:
+
+- Properties passed to a call now override `super_properties`. `super_properties` can no longer change `$lib` or `$lib_version`.
+- A `$is_server`, `$geoip_disable` or system property such as `$os` that you set in a call or a context tag now wins over the SDK's value. In 7.x the SDK overwrote it. `super_properties` win over the SDK's value too, so `super_properties={"$geoip_disable": False}` turns GeoIP lookup on for events, even with `disable_geoip=True`.
+- Feature flag properties from `flags` or `send_feature_flags` still lose to the same key in the call's `properties`, a context tag or `super_properties`, as in 7.x.
+- A `$trace_id` or `$span_id` in a context tag or `super_properties` now replaces the active OpenTelemetry span's IDs. In 7.x the span's IDs beat context tags. Setting either key in the call's `properties`, a context tag or `super_properties` stops the SDK adding both. In 7.x the SDK still added the other key.
+- A `disable_geoip` argument to a call belongs to that event, so it wins over context tags and `super_properties`. A `$geoip_disable` in the call's own `properties` still wins over it. `disable_geoip=False` now sends `$geoip_disable: false`. In 7.x it sent no `$geoip_disable` property.
+- The `groups` argument merges into a `$groups` property of the call, and wins key by key. In 7.x it replaced the property. MCP events merge their identity's groups into a custom `$groups` property the same way.
+- A `$set`, `$set_once`, `$groups` or `$group_set` in `super_properties` no longer replaces the whole value of the call. The two merge, and the call wins key by key.
+- An event without a distinct ID gets `options.process_person_profile = false`. A `$process_person_profile: true` property no longer turns person processing back on. Set the option instead.
+- Review your `before_send` hooks for the new event shape. To change an option, edit `options`: a legacy property that `before_send` adds does not replace an option that is already set. A hook that returns a new dict must copy `options`, or the event is sent without them. That includes the `process_person_profile = false` the SDK sets for an event without a distinct ID, so PostHog would create a person for its generated ID.
+- When the server enables minimal `$feature_flag_called` events, those events now keep `$window_id` and the legacy option properties, so their options still apply.
+
+## AI capture
+
+- `capture_ai` and the AI wrapper integrations send to `/i/v1/ai/events`. The AI endpoint accepts events up to 8 MiB.
+- Send `$ai_` events with `capture_ai`. `capture()` sends every event to `/i/v1/analytics/events`, including `$ai_` events, which PostHog accepts there for now.
+- `capture_ai` sends any event name to the AI endpoint. PostHog drops an event whose name does not start with `$ai_` as `misrouted_event`, and `on_error` reports it. The SDK writes only a debug log.
+- The OpenTelemetry integration (`PostHogSpanProcessor`, `PostHogTraceExporter`) is unchanged: it still exports spans over OTLP to `/i/v0/ai/otel`.
+- `enable_full_ai_capture` now controls only content: string truncation and media redaction. It no longer chooses the endpoint. `_use_ai_lane` and `_enable_multimodal_capture` still work as aliases.
+- The AI integrations call your client's `capture_ai`, and never `capture`. A custom client object must implement `capture_ai` and accept its `options` keyword argument. If the client has no `capture_ai`, the wrapper, callback handler or tracing processor logs one error when you create it and captures no AI events; provider calls still work. Before, such a client got `capture` calls.
+- Tests that pass a `Mock` client to an AI integration must assert on `mock.capture_ai`, not `mock.capture`.
+- When an AI integration or MCP falls back to a trace, run or session ID, it turns person processing off with a per-event option. This is the only option the integrations pass. It wins over `super_options`, context options and a `$process_person_profile: true` property. `before_send` can still change it.
+- An empty or whitespace-only distinct ID passed to an AI integration, such as `posthog_distinct_id=""`, counts as missing, so the integration falls back the same way and turns person processing off. In 7.x, an empty ID gave non-streaming wrapper calls a random personless ID. Streaming calls, embeddings and LangChain used the trace or run ID with person processing on. OpenAI Agents already treated an empty ID as missing. Every integration sent a whitespace-only ID as given, with person processing on.
+- The AI integrations have no `options` argument. To set options on their events, use `set_context_option`, `super_options`, or a legacy property such as `$cookieless_mode` in `posthog_properties`.
+- MCP's `PostHogCaptureEvent` has an `options` key.
+- New `Client` and `AsyncPosthog` arguments for the AI lane:
+  - `capture_ai_compression`: default none. `POSTHOG_CAPTURE_COMPRESSION` does not apply to it.
+  - `capture_ai_max_queue_size`: default 1000
+  - `capture_ai_timeout`: default 30 seconds
+  - `capture_ai_max_event_bytes`: default 8 MiB plus 64 KiB. You can only lower it.
+- The AI lane does not use `max_queue_size`, `timeout` or `capture_compression`. An invalid `capture_ai_*` value raises `ValueError` when you create the client.
+- The module-level client has no AI lane settings. To change them, create a `Client`.
+- `AsyncPosthog` has `capture_ai` and `capture_ai_immediate`.
+- `AsyncPosthog` sends events with `requests` in a worker thread. It uses `httpx` only for feature flags and remote config.
+- `AsyncPosthog` accepts `privacy_mode` and `enable_full_ai_capture`, with the same meaning as on `Client`. An AI integration given an `AsyncPosthog` client used to always truncate and redact media.
+
+## Batching and size limits
+
+- An analytics event over 10 MiB is dropped and logged, because no capture request can carry it. 7.x dropped events over 900 KiB. Capture drops an event over its own per-event limit and reports it in `CaptureError.drops` as `event_too_big`.
+- An AI event over `capture_ai_max_event_bytes` is dropped and logged.
+- A batch stops before an event that would take it past 5 MiB. A larger event is sent alone.
+- `flush()` and `shutdown()` drain the analytics and AI queues at the same time.
+
+## OpenFeature provider
+
+`openfeature-provider-posthog` 0.2.0 works with posthog 7.x and 8.x.
+Older provider versions require posthog below 8.0, so upgrade the provider before or with posthog.

From 21c828c0a1417489c03f64cbfb319c5407dc72fb Mon Sep 17 00:00:00 2001
From: "Vincent (Wen Yu) Ge" <29069505+gewenyu99@users.noreply.github.com>
Date: Tue, 10 Nov 2026 15:11:37 -0500
Subject: [PATCH 236/245] docs: generate the Markdown reference on release and
 remove HogRef generation (#1185)

* docs: generate the Markdown reference on release and remove HogRef generation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: add a workflow that regenerates the reference by hand

The release's reference step is best-effort, so a failure never blocks a
release. generate-references.yml reruns it from main on demand and commits
references/ when anything changed. Same shape as posthog-js's
generate-references.yml.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: install the dev extra in the manual reference run, and don't let the sdk-specs checkout block a release

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: warn when the SDK reference doesn't regenerate

The reference step is best-effort, so a failure leaves the release green. A
::warning:: annotation now says so and points to generate-references.yml.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/generate-references.yml |  64 +++
 .github/workflows/release.yml             |  20 +-
 bin/docs                                  |   6 +-
 bin/docs_scripts/doc_constant.py          |  43 --
 bin/docs_scripts/generate_json_schemas.py | 498 ----------------------
 5 files changed, 86 insertions(+), 545 deletions(-)
 create mode 100644 .github/workflows/generate-references.yml
 delete mode 100644 bin/docs_scripts/doc_constant.py
 delete mode 100644 bin/docs_scripts/generate_json_schemas.py

diff --git a/.github/workflows/generate-references.yml b/.github/workflows/generate-references.yml
new file mode 100644
index 000000000..708e21322
--- /dev/null
+++ b/.github/workflows/generate-references.yml
@@ -0,0 +1,64 @@
+name: Generate references
+
+# Regenerates references/ by hand, for when the release's best-effort reference step fails
+# or the pages need a refresh. Same shape as posthog-js's generate-references.yml.
+on:
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  generate-references:
+    name: Generate SDK reference
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Get GitHub App token
+        id: releaser
+        uses: actions/create-github-app-token@64ab729a6294000f5aa4a4bc0b73d1f32bc45510 # v3.3.0
+        with:
+          client-id: ${{ secrets.GH_APP_POSTHOG_PYTHON_RELEASER_APP_ID }}
+          private-key: ${{ secrets.GH_APP_POSTHOG_PYTHON_RELEASER_PRIVATE_KEY }}
+
+      - name: Checkout repository
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: main
+          token: ${{ steps.releaser.outputs.token }}
+
+      - name: Check out sdk-specs
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: PostHog/sdk-specs
+          path: .sdk-specs
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: 3.11
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        with:
+          version: "0.13.4"
+          enable-cache: true
+
+      - name: Generate references
+        id: changes
+        run: |
+          uv run --extra dev bin/docs --sdk-specs .sdk-specs
+          git add references
+          git diff --cached --quiet || echo "changed=true" >> "$GITHUB_OUTPUT"
+
+      - name: Commit generated references
+        if: steps.changes.outputs.changed == 'true'
+        uses: planetscale/ghcommit-action@a6b150b81dca5dd027baa898604418eec9e11465 # v0.2.22
+        with:
+          commit_message: "docs: update the SDK reference [skip ci]"
+          repo: ${{ github.repository }}
+          branch: main
+          file_pattern: references/
+        env:
+          GITHUB_TOKEN: ${{ steps.releaser.outputs.token }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index e7d0fc916..77b77bbb7 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -198,10 +198,28 @@ jobs:
           git fetch origin main
           git reset --hard "$COMMIT_HASH"
 
+      # The reference headings come from the sdk-specs capabilities.
+      - name: Check out sdk-specs
+        # Best-effort: a failure never blocks the release. Run generate-references.yml to retry.
+        continue-on-error: true
+        if: steps.commit-release.outputs.commit-hash != ''
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: PostHog/sdk-specs
+          path: .sdk-specs
+          persist-credentials: false
+
       - name: Generate references
+        id: reference
+        # Best-effort: a failure never blocks the release. Run generate-references.yml to retry.
+        continue-on-error: true
         if: steps.commit-release.outputs.commit-hash != ''
         run: |
-          uv run bin/docs generate-references
+          uv run bin/docs --sdk-specs .sdk-specs
+
+      - name: Warn if the SDK reference didn't regenerate
+        if: steps.reference.outcome == 'failure'
+        run: echo "::warning::The SDK reference didn't regenerate. Run generate-references.yml to retry."
 
       - name: Check for changes in references
         if: steps.commit-release.outputs.commit-hash != ''
diff --git a/bin/docs b/bin/docs
index 9943b4c0f..3e0ad888d 100755
--- a/bin/docs
+++ b/bin/docs
@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
-#/ Usage: bin/docs
-#/ Description: Generate documentation for the PostHog Python SDK
+#/ Usage: bin/docs --sdk-specs <PostHog/sdk-specs checkout>
+#/ Description: Generate the Markdown reference for the PostHog Python SDK
 source bin/helpers/_utils.sh
 set_source_and_root_dir
 ensure_virtual_env
 
-exec python3 "$(dirname "$0")/docs_scripts/generate_json_schemas.py" "$@" 
\ No newline at end of file
+exec python3 "$(dirname "$0")/docs_scripts/generate_markdown.py" "$@"
diff --git a/bin/docs_scripts/doc_constant.py b/bin/docs_scripts/doc_constant.py
deleted file mode 100644
index 9136e6892..000000000
--- a/bin/docs_scripts/doc_constant.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
-Constants for PostHog Python SDK documentation generation.
-"""
-
-from typing import Dict, Union
-from posthog.version import VERSION
-
-# Documentation generation metadata
-DOCUMENTATION_METADATA = {
-    "hogRef": "0.3",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python",
-}
-
-# Docstring parsing patterns for new format
-DOCSTRING_PATTERNS = {
-    "examples_section": r"Examples:\s*\n(.*?)(?=\n\s*\n\s*Category:|\Z)",
-    "args_section": r"Args:\s*\n(.*?)(?=\n\s*\n\s*Examples:|\n\s*\n\s*Details:|\n\s*\n\s*Category:|\Z)",
-    "details_section": r"Details:\s*\n(.*?)(?=\n\s*\n\s*Examples:|\n\s*\n\s*Category:|\Z)",
-    "category_section": r"Category:\s*\n\s*(.+?)\s*(?:\n|$)",
-    "code_block": r"```(?:python)?\n(.*?)```",
-    "param_description": r"^\s*{param_name}:\s*(.+?)(?=\n\s*\w+:|\Z)",
-    "args_marker": r"\n\s*Args:\s*\n",
-    "examples_marker": r"\n\s*Examples:\s*\n",
-    "details_marker": r"\n\s*Details:\s*\n",
-    "category_marker": r"\n\s*Category:\s*\n",
-}
-
-# Output file configuration
-OUTPUT_CONFIG: Dict[str, Union[str, int]] = {
-    "output_dir": "./references",
-    "filename": f"posthog-python-references-{VERSION}.json",
-    "filename_latest": "posthog-python-references-latest.json",
-    "indent": 2,
-}
-
-# Documentation structure defaults
-DOC_DEFAULTS = {
-    "showDocs": True,
-    "releaseTag": "public",
-    "return_type_void": "None",
-    "max_optional_params": 3,
-}
diff --git a/bin/docs_scripts/generate_json_schemas.py b/bin/docs_scripts/generate_json_schemas.py
deleted file mode 100644
index 742688a35..000000000
--- a/bin/docs_scripts/generate_json_schemas.py
+++ /dev/null
@@ -1,498 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate comprehensive SDK documentation JSON from PostHog Python SDK.
-This script inspects the code and docstrings to create documentation in the specified format.
-"""
-
-import json
-import inspect
-import re
-from dataclasses import is_dataclass, fields
-from typing import get_origin, get_args, Union
-from textwrap import dedent
-from doc_constant import (
-    DOCUMENTATION_METADATA,
-    DOCSTRING_PATTERNS,
-    OUTPUT_CONFIG,
-    DOC_DEFAULTS,
-)
-import os
-
-
-def extract_examples_from_docstring(docstring: str) -> list:
-    """Extract code examples from docstring."""
-    if not docstring:
-        return []
-
-    examples = []
-
-    # Look for Examples section in the new format
-    examples_section_match = re.search(
-        DOCSTRING_PATTERNS["examples_section"], docstring, re.DOTALL
-    )
-    if examples_section_match:
-        examples_content = examples_section_match.group(1).strip()
-        # Extract code blocks from the Examples section
-        code_blocks = re.findall(
-            DOCSTRING_PATTERNS["code_block"], examples_content, re.DOTALL
-        )
-        for i, code_block in enumerate(code_blocks):
-            # Remove common leading whitespace while preserving relative indentation
-            code = dedent(code_block).strip()
-
-            # Extract name from first comment line if present
-            lines = code.split("\n")
-            name = f"Example {i + 1}"  # Default fallback
-
-            if lines and lines[0].strip().startswith("#"):
-                # Extract name from first comment, keep the comment in the code
-                comment_text = lines[0].strip()[1:].strip()
-                if comment_text:
-                    name = comment_text
-
-            examples.append({"id": f"example_{i + 1}", "name": name, "code": code})
-
-    return examples
-
-
-def extract_details_from_docstring(docstring: str) -> str:
-    """Extract details section from docstring."""
-    if not docstring:
-        return ""
-
-    # Look for Details section
-    details_match = re.search(
-        DOCSTRING_PATTERNS["details_section"], docstring, re.DOTALL
-    )
-    if details_match:
-        details_content = details_match.group(1).strip()
-        # Clean up formatting
-        return details_content.replace("\n", " ")
-
-    return ""
-
-
-def parse_docstring_tags(docstring: str) -> dict:
-    """Parse tags from docstring Category section."""
-    if not docstring:
-        return {}
-
-    tags = {}
-
-    # Extract Category section
-    category_match = re.search(DOCSTRING_PATTERNS["category_section"], docstring)
-    if category_match:
-        category_value = category_match.group(1).strip()
-        tags["category"] = category_value
-
-    return tags
-
-
-def extract_description_from_docstring(docstring: str) -> str:
-    """Extract main description from docstring."""
-    if not docstring:
-        return ""
-
-    # Clean up the docstring
-    cleaned = dedent(docstring).strip()
-
-    # Find the end of the description by looking for first section marker
-    # Check for Args:, Examples:, Details:, or Category: sections
-    section_patterns = [
-        DOCSTRING_PATTERNS["args_marker"],
-        DOCSTRING_PATTERNS["examples_marker"],
-        DOCSTRING_PATTERNS["details_marker"],
-        DOCSTRING_PATTERNS["category_marker"],
-    ]
-
-    end_pos = len(cleaned)
-    for pattern in section_patterns:
-        match = re.search(pattern, cleaned)
-        if match:
-            end_pos = min(end_pos, match.start())
-
-    # Extract description up to the first section marker
-    description = cleaned[:end_pos].strip()
-
-    # Remove one level of \n since it will be rendered as markdown
-    # and \n will be padded in later steps
-    description = description.replace("\n", " ")
-
-    return description
-
-
-def get_type_name(type_annotation) -> str:
-    """Convert type annotation to string name."""
-    if type_annotation is None or type_annotation is type(None):
-        return "any"
-
-    # Handle typing constructs
-    origin = get_origin(type_annotation)
-    if origin is not None:
-        # Handle Union types (including Optional)
-        if origin is Union:
-            args = get_args(type_annotation)
-            if len(args) == 2 and type(None) in args:
-                # This is Optional[Type] - get the non-None type
-                non_none_type = next(arg for arg in args if arg is not type(None))
-                return f"Optional[{get_type_name(non_none_type)}]"
-            else:
-                # Regular Union - list all types
-                type_names = [get_type_name(arg) for arg in args]
-                return f"Union[{', '.join(type_names)}]"
-
-        # Handle other generic types (List, Dict, etc.)
-        origin_name = getattr(origin, "__name__", str(origin))
-        args = get_args(type_annotation)
-        if args:
-            arg_names = [get_type_name(arg) for arg in args]
-            return f"{origin_name}[{', '.join(arg_names)}]"
-        else:
-            return origin_name
-
-    # Handle regular types
-    elif hasattr(type_annotation, "__name__"):
-        return type_annotation.__name__
-    else:
-        return str(type_annotation)
-
-
-def analyze_parameter(param: inspect.Parameter, docstring: str = "") -> dict:
-    """Analyze a function parameter and return its documentation."""
-    # Determine if parameter is optional (has default value)
-    is_optional = param.default == inspect.Parameter.empty
-
-    # Get the type annotation
-    type_annotation = param.annotation
-    param_type = "any"
-
-    if type_annotation != inspect.Parameter.empty:
-        # Handle Union/Optional types first
-        origin = get_origin(type_annotation)
-        if origin is Union:
-            args = get_args(type_annotation)
-            if len(args) == 2 and type(None) in args:
-                # This is Optional[Type]
-                non_none_type = next(arg for arg in args if arg is not type(None))
-                param_type = get_type_name(non_none_type)
-                is_optional = True
-            else:
-                # Other Union types, use first type
-                param_type = get_type_name(args[0]) if args else "any"
-        else:
-            param_type = get_type_name(type_annotation)
-    elif param.default != inspect.Parameter.empty:
-        # No type annotation, but has default value - infer type from default
-        param_type = get_type_name(type(param.default))
-
-    # Extract parameter description from Args section
-    param_description = ""
-    if docstring:
-        # Look for Args section and extract description for this parameter
-        args_section_match = re.search(
-            DOCSTRING_PATTERNS["args_section"], docstring, re.DOTALL
-        )
-        if args_section_match:
-            args_content = args_section_match.group(1)
-            # Look for the parameter description
-            param_pattern = DOCSTRING_PATTERNS["param_description"].format(
-                param_name=re.escape(param.name)
-            )
-            param_match = re.search(
-                param_pattern, args_content, re.MULTILINE | re.DOTALL
-            )
-            if param_match:
-                param_description = param_match.group(1).strip().replace("\n", " ")
-
-    param_info = {
-        "name": param.name,
-        "description": param_description,
-        "isOptional": is_optional,
-        "type": param_type,
-    }
-
-    return param_info
-
-
-def analyze_function(func, name: str) -> dict:
-    """Analyze a function and return its documentation."""
-    try:
-        sig = inspect.signature(func)
-        docstring = inspect.getdoc(func) or ""
-
-        # Skip functions with empty docstrings
-        if not docstring.strip():
-            return {}
-
-        # Extract parameters (excluding 'self')
-        params = []
-        for param_name, param in sig.parameters.items():
-            if param_name != "self":
-                params.append(analyze_parameter(param, docstring))
-
-        # Special handling for constructor
-        display_name = name
-        if name == "__init__":
-            display_name = func.__qualname__.split(".")[0]
-
-        # Parse tags from docstring
-        tags = parse_docstring_tags(docstring)
-
-        category = tags.get("category", None)
-
-        # Extract description
-        description = extract_description_from_docstring(docstring)
-
-        # Skip if no meaningful description
-        if not description.strip():
-            return {}
-
-        # Extract details section (only if it exists)
-        details = extract_details_from_docstring(docstring)
-
-        # Get examples from docstring, do not generate fallback examples
-        examples = extract_examples_from_docstring(docstring)
-        # If no examples, do not include the examples key or set to empty list
-
-        result = {
-            "id": name,
-            "title": display_name,
-            "description": description,
-            "details": details,
-            "category": category,
-            "params": params,
-            "showDocs": DOC_DEFAULTS["showDocs"],
-            "releaseTag": DOC_DEFAULTS["releaseTag"],
-            "returnType": {
-                "id": "return_type",
-                "name": get_type_name(sig.return_annotation)
-                if sig.return_annotation != inspect.Signature.empty
-                else DOC_DEFAULTS["return_type_void"],
-            },
-        }
-        if examples:
-            result["examples"] = examples
-        return result
-    except Exception as e:
-        print(f"Error analyzing function {name}: {e}")
-        return {}
-
-
-def analyze_class(cls) -> dict:
-    """Analyze a class and return its documentation."""
-    class_doc = inspect.getdoc(cls) or f"Class: {cls.__name__}"
-
-    # Get all public methods and constructor
-    functions = []
-    for method_name in dir(cls):
-        if method_name.startswith("_") and method_name != "__init__":
-            continue
-
-        method = getattr(cls, method_name)
-        if callable(method):
-            func_info = analyze_function(method, method_name)
-            if func_info:  # Only add if not None (empty docstring check)
-                functions.append(func_info)
-
-    return {
-        "id": cls.__name__,
-        "title": cls.__name__,
-        "description": extract_description_from_docstring(class_doc),
-        "functions": functions,
-    }
-
-
-def analyze_type(cls) -> dict:
-    """Analyze a type/dataclass and return its documentation."""
-    type_info = {
-        "id": cls.__name__,
-        "name": cls.__name__,
-        "path": f"{cls.__module__}.{cls.__name__}",
-        "properties": [],
-        "example": "",
-    }
-
-    if is_dataclass(cls):
-        # Handle dataclass
-        for field in fields(cls):
-            prop = {
-                "name": field.name,
-                "type": get_type_name(field.type),
-                "description": f"Field: {field.name}",
-            }
-            type_info["properties"].append(prop)
-    elif hasattr(cls, "__annotations__"):
-        # Handle TypedDict or annotated class
-        for field_name, field_type in cls.__annotations__.items():
-            prop = {
-                "name": field_name,
-                "type": get_type_name(field_type),
-                "description": f"Field: {field_name}",
-            }
-            type_info["properties"].append(prop)
-
-    return type_info
-
-
-def generate_sdk_documentation():
-    """Generate complete SDK documentation in the requested format."""
-
-    # Import PostHog components
-    import posthog
-    from posthog.client import Client
-    import posthog.types as types_module
-    import posthog.args as args_module
-    from posthog.version import VERSION
-
-    # Main SDK info
-    sdk_info = {
-        "version": VERSION,
-        "id": "posthog-python",
-        "title": "PostHog Python SDK",
-        "description": "Integrate PostHog into any python application.",
-        "slugPrefix": DOCUMENTATION_METADATA["slugPrefix"],
-        "specUrl": DOCUMENTATION_METADATA["specUrl"],
-    }
-
-    # Collect types
-    types_list = []
-
-    # Types from posthog.types
-    for name in dir(types_module):
-        obj = getattr(types_module, name)
-        if inspect.isclass(obj) and not name.startswith("_"):
-            try:
-                type_info = analyze_type(obj)
-                types_list.append(type_info)
-            except Exception as e:
-                print(f"Error analyzing type {name}: {e}")
-
-    # Types from posthog.args
-    for name in dir(args_module):
-        obj = getattr(args_module, name)
-        if inspect.isclass(obj) and not name.startswith("_"):
-            try:
-                type_info = analyze_type(obj)
-                types_list.append(type_info)
-            except Exception as e:
-                print(f"Error analyzing type {name}: {e}")
-
-    # Clean types of empty types
-
-    # Remove types that have no properties and no examples
-    # Remove types that have no properties and no examples
-    types_list = [
-        t for t in types_list if len(t["properties"]) > 0 or t["example"] != ""
-    ]
-
-    # Collect classes
-    classes_list = []
-
-    # Main PostHog class (renamed from Client)
-    client_class = analyze_class(Client)
-    client_class["id"] = "PostHog"
-    client_class["title"] = "PostHog"
-    classes_list.append(client_class)
-
-    # Global module functions (functions callable as posthog.function_name)
-    global_functions = []
-    for func_name in dir(posthog):
-        # Skip private functions and non-callables
-        if func_name.startswith("_") or not callable(getattr(posthog, func_name)):
-            continue
-
-        func = getattr(posthog, func_name)
-        # Only include functions actually defined in the posthog module (not imported)
-        # and exclude class references
-        if (
-            func_name not in ["Client", "Posthog"]
-            and hasattr(func, "__module__")
-            and func.__module__ == "posthog"
-        ):
-            try:
-                func_info = analyze_function(func, func_name)
-                if func_info:  # Only add if not None (has proper docstring)
-                    global_functions.append(func_info)
-            except Exception:
-                continue
-
-    # Add global functions as a "class"
-    if global_functions:
-        classes_list.append(
-            {
-                "id": "PostHogModule",
-                "title": "PostHog Module Functions",
-                "description": "Global functions available in the PostHog module",
-                "functions": global_functions,
-            }
-        )
-
-    # Collect categories from functions
-    categories = ["Initialization", "Identification", "Capture"]
-    seen_categories = set(categories)
-    for class_info in classes_list:
-        if "functions" in class_info:
-            for func in class_info["functions"]:
-                if (
-                    "category" in func
-                    and func["category"] not in seen_categories
-                    and func["category"]
-                ):
-                    categories.append(func["category"])
-                    seen_categories.add(func["category"])
-
-    # Create the final structure
-    result = {
-        "id": "posthog-python",
-        "hogRef": DOCUMENTATION_METADATA["hogRef"],
-        "info": sdk_info,
-        "types": types_list,
-        "classes": classes_list,
-        "categories": categories,
-    }
-
-    return result
-
-
-if __name__ == "__main__":
-    print("Generating PostHog Python SDK documentation...")
-
-    try:
-        documentation = generate_sdk_documentation()
-
-        # Ensure output directory exists
-        output_dir = str(OUTPUT_CONFIG["output_dir"])
-        os.makedirs(output_dir, exist_ok=True)
-
-        output_file = os.path.join(
-            str(OUTPUT_CONFIG["output_dir"]), str(OUTPUT_CONFIG["filename"])
-        )
-        output_file_latest = os.path.join(
-            str(OUTPUT_CONFIG["output_dir"]), str(OUTPUT_CONFIG["filename_latest"])
-        )
-
-        # Write to current version
-        with open(output_file, "w") as f:
-            json.dump(documentation, f, indent=int(OUTPUT_CONFIG["indent"]))
-        # Write to latest
-        with open(output_file_latest, "w") as f:
-            json.dump(documentation, f, indent=int(OUTPUT_CONFIG["indent"]))
-
-        print(f"✓ Generated {output_file}")
-
-        # Print summary
-        types_count = len(documentation["types"])
-        classes_count = len(documentation["classes"])
-
-        total_functions = sum(len(cls["functions"]) for cls in documentation["classes"])
-
-        print("📊 Documentation Summary:")
-        print(f"   • {types_count} types documented")
-        print(f"   • {classes_count} classes documented")
-        print(f"   • {total_functions} functions documented")
-
-    except Exception as e:
-        print(f"❌ Error generating documentation: {e}")
-        import traceback
-
-        traceback.print_exc()

From ae8f0bd2caa2f562da57127b31601aa35147d9d7 Mon Sep 17 00:00:00 2001
From: "Vincent (Wen Yu) Ge" <29069505+gewenyu99@users.noreply.github.com>
Date: Tue, 10 Nov 2026 18:04:50 -0500
Subject: [PATCH 237/245] chore(references): keep HogRef JSON only for versions
 people install (#1225)

* chore(references): keep only the newest HogRef JSON per major

Strapi's HogRef cron downloads every file in references/ every 15
minutes. With 194 versioned files here and over 1,000 across the JS
packages, it uses up its GitHub token's hourly budget, and other syncs
on the same token fail. Strapi already stores every version, so the
files are only needed for new releases.

Keep 6.9.3, 7.86.6 and latest. New releases still add their file.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(references): keep the latest patch of each minor that changed the reference

Restore the latest patch of every minor whose reference differs from the
release before it, plus the newest release of each major. Minors that
only bumped the version number stay deleted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(references): keep only references for versions people install

Of the files the previous commit kept, keep only those whose versions get
at least 1% of the package's weekly downloads, plus the newest release
of each major. A file also counts downloads of later minors that share
its reference.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../posthog-python-references-6.7.10.json     | 2343 -----------
 .../posthog-python-references-6.7.11.json     | 2343 -----------
 .../posthog-python-references-6.7.12.json     | 2343 -----------
 .../posthog-python-references-6.7.13.json     | 2343 -----------
 .../posthog-python-references-6.7.7.json      | 2343 -----------
 .../posthog-python-references-6.8.0.json      | 2343 -----------
 .../posthog-python-references-6.9.0.json      | 2430 -----------
 .../posthog-python-references-6.9.1.json      | 2425 -----------
 .../posthog-python-references-6.9.2.json      | 2425 -----------
 .../posthog-python-references-7.0.0.json      | 2425 -----------
 .../posthog-python-references-7.0.1.json      | 2425 -----------
 .../posthog-python-references-7.14.0.json     | 2725 -------------
 .../posthog-python-references-7.14.1.json     | 2725 -------------
 .../posthog-python-references-7.15.0.json     | 2725 -------------
 .../posthog-python-references-7.15.1.json     | 2912 --------------
 .../posthog-python-references-7.15.3.json     | 2912 --------------
 .../posthog-python-references-7.15.4.json     | 2912 --------------
 .../posthog-python-references-7.16.0.json     | 2912 --------------
 .../posthog-python-references-7.16.1.json     | 2912 --------------
 .../posthog-python-references-7.16.2.json     | 2912 --------------
 .../posthog-python-references-7.16.3.json     | 2912 --------------
 .../posthog-python-references-7.16.4.json     | 2912 --------------
 .../posthog-python-references-7.17.0.json     | 2918 --------------
 .../posthog-python-references-7.18.0.json     | 2918 --------------
 .../posthog-python-references-7.18.1.json     | 2924 --------------
 .../posthog-python-references-7.18.2.json     | 2924 --------------
 .../posthog-python-references-7.18.3.json     | 2924 --------------
 .../posthog-python-references-7.19.0.json     | 2948 --------------
 .../posthog-python-references-7.19.1.json     | 2948 --------------
 .../posthog-python-references-7.19.2.json     | 2948 --------------
 .../posthog-python-references-7.20.0.json     | 3093 --------------
 .../posthog-python-references-7.20.1.json     | 3093 --------------
 .../posthog-python-references-7.20.2.json     | 3120 --------------
 .../posthog-python-references-7.20.3.json     | 3147 ---------------
 .../posthog-python-references-7.20.4.json     | 3147 ---------------
 .../posthog-python-references-7.20.5.json     | 3147 ---------------
 .../posthog-python-references-7.21.0.json     | 3147 ---------------
 .../posthog-python-references-7.21.1.json     | 3147 ---------------
 .../posthog-python-references-7.21.2.json     | 3147 ---------------
 .../posthog-python-references-7.22.0.json     | 3171 ---------------
 .../posthog-python-references-7.22.1.json     | 3171 ---------------
 .../posthog-python-references-7.22.2.json     | 3171 ---------------
 .../posthog-python-references-7.22.3.json     | 3171 ---------------
 .../posthog-python-references-7.23.0.json     | 3177 ---------------
 .../posthog-python-references-7.24.0.json     | 3182 ---------------
 .../posthog-python-references-7.25.0.json     | 3182 ---------------
 .../posthog-python-references-7.26.0.json     | 3182 ---------------
 .../posthog-python-references-7.27.0.json     | 3192 ---------------
 .../posthog-python-references-7.28.0.json     | 3192 ---------------
 .../posthog-python-references-7.29.0.json     | 3198 ---------------
 .../posthog-python-references-7.30.0.json     | 3198 ---------------
 .../posthog-python-references-7.30.1.json     | 3198 ---------------
 .../posthog-python-references-7.31.0.json     | 3198 ---------------
 .../posthog-python-references-7.31.1.json     | 3198 ---------------
 .../posthog-python-references-7.32.0.json     | 3198 ---------------
 .../posthog-python-references-7.33.0.json     | 3198 ---------------
 .../posthog-python-references-7.34.0.json     | 3198 ---------------
 .../posthog-python-references-7.35.0.json     | 3198 ---------------
 .../posthog-python-references-7.35.1.json     | 3198 ---------------
 .../posthog-python-references-7.35.2.json     | 3198 ---------------
 .../posthog-python-references-7.35.3.json     | 3198 ---------------
 .../posthog-python-references-7.35.4.json     | 3198 ---------------
 .../posthog-python-references-7.35.5.json     | 3198 ---------------
 .../posthog-python-references-7.36.0.json     | 3198 ---------------
 .../posthog-python-references-7.37.0.json     | 3198 ---------------
 .../posthog-python-references-7.37.1.json     | 3198 ---------------
 .../posthog-python-references-7.37.2.json     | 3198 ---------------
 .../posthog-python-references-7.37.3.json     | 3198 ---------------
 .../posthog-python-references-7.37.4.json     | 3198 ---------------
 .../posthog-python-references-7.37.5.json     | 3198 ---------------
 .../posthog-python-references-7.37.6.json     | 3198 ---------------
 .../posthog-python-references-7.38.0.json     | 3198 ---------------
 .../posthog-python-references-7.38.1.json     | 3198 ---------------
 .../posthog-python-references-7.38.2.json     | 3198 ---------------
 .../posthog-python-references-7.38.3.json     | 3198 ---------------
 .../posthog-python-references-7.38.4.json     | 3198 ---------------
 .../posthog-python-references-7.38.5.json     | 3198 ---------------
 .../posthog-python-references-7.38.6.json     | 3198 ---------------
 .../posthog-python-references-7.39.0.json     | 3265 ---------------
 .../posthog-python-references-7.39.1.json     | 3265 ---------------
 .../posthog-python-references-7.40.0.json     | 3265 ---------------
 .../posthog-python-references-7.41.0.json     | 3265 ---------------
 .../posthog-python-references-7.42.0.json     | 3265 ---------------
 .../posthog-python-references-7.42.1.json     | 3265 ---------------
 .../posthog-python-references-7.43.0.json     | 3265 ---------------
 .../posthog-python-references-7.44.0.json     | 3271 ---------------
 .../posthog-python-references-7.44.1.json     | 3271 ---------------
 .../posthog-python-references-7.44.2.json     | 3271 ---------------
 .../posthog-python-references-7.45.0.json     | 3271 ---------------
 .../posthog-python-references-7.45.1.json     | 3271 ---------------
 .../posthog-python-references-7.45.2.json     | 3271 ---------------
 .../posthog-python-references-7.45.3.json     | 3271 ---------------
 .../posthog-python-references-7.46.0.json     | 3271 ---------------
 .../posthog-python-references-7.47.0.json     | 3271 ---------------
 .../posthog-python-references-7.47.1.json     | 3271 ---------------
 .../posthog-python-references-7.47.2.json     | 3271 ---------------
 .../posthog-python-references-7.47.3.json     | 3271 ---------------
 .../posthog-python-references-7.48.0.json     | 3271 ---------------
 .../posthog-python-references-7.49.0.json     | 3271 ---------------
 .../posthog-python-references-7.50.0.json     | 3271 ---------------
 .../posthog-python-references-7.51.0.json     | 3271 ---------------
 .../posthog-python-references-7.51.1.json     | 3271 ---------------
 .../posthog-python-references-7.51.2.json     | 3271 ---------------
 .../posthog-python-references-7.52.0.json     | 3271 ---------------
 .../posthog-python-references-7.52.1.json     | 3271 ---------------
 .../posthog-python-references-7.53.0.json     | 3271 ---------------
 .../posthog-python-references-7.54.0.json     | 3271 ---------------
 .../posthog-python-references-7.54.1.json     | 3271 ---------------
 .../posthog-python-references-7.54.2.json     | 3271 ---------------
 .../posthog-python-references-7.55.0.json     | 3271 ---------------
 .../posthog-python-references-7.56.0.json     | 3271 ---------------
 .../posthog-python-references-7.57.0.json     | 3271 ---------------
 .../posthog-python-references-7.58.0.json     | 3436 ----------------
 .../posthog-python-references-7.59.0.json     | 3436 ----------------
 .../posthog-python-references-7.59.1.json     | 3436 ----------------
 .../posthog-python-references-7.59.2.json     | 3436 ----------------
 .../posthog-python-references-7.60.0.json     | 3548 ----------------
 .../posthog-python-references-7.60.1.json     | 3548 ----------------
 .../posthog-python-references-7.61.0.json     | 3548 ----------------
 .../posthog-python-references-7.61.1.json     | 3548 ----------------
 .../posthog-python-references-7.62.0.json     | 3548 ----------------
 .../posthog-python-references-7.62.1.json     | 3548 ----------------
 .../posthog-python-references-7.63.0.json     | 3548 ----------------
 .../posthog-python-references-7.64.0.json     | 3548 ----------------
 .../posthog-python-references-7.64.1.json     | 3548 ----------------
 .../posthog-python-references-7.66.0.json     | 3548 ----------------
 .../posthog-python-references-7.67.0.json     | 3548 ----------------
 .../posthog-python-references-7.67.1.json     | 3548 ----------------
 .../posthog-python-references-7.68.0.json     | 3548 ----------------
 .../posthog-python-references-7.69.0.json     | 3548 ----------------
 .../posthog-python-references-7.70.0.json     | 3548 ----------------
 .../posthog-python-references-7.70.1.json     | 3548 ----------------
 .../posthog-python-references-7.70.2.json     | 3548 ----------------
 .../posthog-python-references-7.72.0.json     | 3548 ----------------
 .../posthog-python-references-7.73.0.json     | 3548 ----------------
 .../posthog-python-references-7.73.1.json     | 3548 ----------------
 .../posthog-python-references-7.73.2.json     | 3548 ----------------
 .../posthog-python-references-7.73.3.json     | 3548 ----------------
 .../posthog-python-references-7.74.0.json     | 3548 ----------------
 .../posthog-python-references-7.75.0.json     | 3548 ----------------
 .../posthog-python-references-7.75.1.json     | 3548 ----------------
 .../posthog-python-references-7.75.10.json    | 3548 ----------------
 .../posthog-python-references-7.75.2.json     | 3548 ----------------
 .../posthog-python-references-7.75.3.json     | 3548 ----------------
 .../posthog-python-references-7.75.4.json     | 3548 ----------------
 .../posthog-python-references-7.75.5.json     | 3548 ----------------
 .../posthog-python-references-7.75.6.json     | 3548 ----------------
 .../posthog-python-references-7.75.7.json     | 3548 ----------------
 .../posthog-python-references-7.75.8.json     | 3548 ----------------
 .../posthog-python-references-7.75.9.json     | 3548 ----------------
 .../posthog-python-references-7.76.0.json     | 3548 ----------------
 .../posthog-python-references-7.76.1.json     | 3548 ----------------
 .../posthog-python-references-7.77.0.json     | 3548 ----------------
 .../posthog-python-references-7.78.0.json     | 3548 ----------------
 .../posthog-python-references-7.79.0.json     | 3548 ----------------
 .../posthog-python-references-7.80.0.json     | 3548 ----------------
 .../posthog-python-references-7.80.1.json     | 3548 ----------------
 .../posthog-python-references-7.80.2.json     | 3548 ----------------
 .../posthog-python-references-7.80.3.json     | 3548 ----------------
 .../posthog-python-references-7.81.0.json     | 3566 ----------------
 .../posthog-python-references-7.81.1.json     | 3566 ----------------
 .../posthog-python-references-7.82.0.json     | 3566 ----------------
 .../posthog-python-references-7.82.1.json     | 3566 ----------------
 .../posthog-python-references-7.82.2.json     | 3566 ----------------
 .../posthog-python-references-7.83.0.json     | 3566 ----------------
 .../posthog-python-references-7.83.1.json     | 3566 ----------------
 .../posthog-python-references-7.83.2.json     | 3566 ----------------
 .../posthog-python-references-7.84.0.json     | 3572 -----------------
 .../posthog-python-references-7.84.1.json     | 3572 -----------------
 .../posthog-python-references-7.84.2.json     | 3572 -----------------
 .../posthog-python-references-7.85.0.json     | 3572 -----------------
 .../posthog-python-references-7.86.0.json     | 3572 -----------------
 .../posthog-python-references-7.86.1.json     | 3572 -----------------
 .../posthog-python-references-7.86.2.json     | 3572 -----------------
 .../posthog-python-references-7.86.3.json     | 3572 -----------------
 .../posthog-python-references-7.86.4.json     | 3572 -----------------
 .../posthog-python-references-7.86.5.json     | 3572 -----------------
 177 files changed, 575560 deletions(-)
 delete mode 100644 references/posthog-python-references-6.7.10.json
 delete mode 100644 references/posthog-python-references-6.7.11.json
 delete mode 100644 references/posthog-python-references-6.7.12.json
 delete mode 100644 references/posthog-python-references-6.7.13.json
 delete mode 100644 references/posthog-python-references-6.7.7.json
 delete mode 100644 references/posthog-python-references-6.8.0.json
 delete mode 100644 references/posthog-python-references-6.9.0.json
 delete mode 100644 references/posthog-python-references-6.9.1.json
 delete mode 100644 references/posthog-python-references-6.9.2.json
 delete mode 100644 references/posthog-python-references-7.0.0.json
 delete mode 100644 references/posthog-python-references-7.0.1.json
 delete mode 100644 references/posthog-python-references-7.14.0.json
 delete mode 100644 references/posthog-python-references-7.14.1.json
 delete mode 100644 references/posthog-python-references-7.15.0.json
 delete mode 100644 references/posthog-python-references-7.15.1.json
 delete mode 100644 references/posthog-python-references-7.15.3.json
 delete mode 100644 references/posthog-python-references-7.15.4.json
 delete mode 100644 references/posthog-python-references-7.16.0.json
 delete mode 100644 references/posthog-python-references-7.16.1.json
 delete mode 100644 references/posthog-python-references-7.16.2.json
 delete mode 100644 references/posthog-python-references-7.16.3.json
 delete mode 100644 references/posthog-python-references-7.16.4.json
 delete mode 100644 references/posthog-python-references-7.17.0.json
 delete mode 100644 references/posthog-python-references-7.18.0.json
 delete mode 100644 references/posthog-python-references-7.18.1.json
 delete mode 100644 references/posthog-python-references-7.18.2.json
 delete mode 100644 references/posthog-python-references-7.18.3.json
 delete mode 100644 references/posthog-python-references-7.19.0.json
 delete mode 100644 references/posthog-python-references-7.19.1.json
 delete mode 100644 references/posthog-python-references-7.19.2.json
 delete mode 100644 references/posthog-python-references-7.20.0.json
 delete mode 100644 references/posthog-python-references-7.20.1.json
 delete mode 100644 references/posthog-python-references-7.20.2.json
 delete mode 100644 references/posthog-python-references-7.20.3.json
 delete mode 100644 references/posthog-python-references-7.20.4.json
 delete mode 100644 references/posthog-python-references-7.20.5.json
 delete mode 100644 references/posthog-python-references-7.21.0.json
 delete mode 100644 references/posthog-python-references-7.21.1.json
 delete mode 100644 references/posthog-python-references-7.21.2.json
 delete mode 100644 references/posthog-python-references-7.22.0.json
 delete mode 100644 references/posthog-python-references-7.22.1.json
 delete mode 100644 references/posthog-python-references-7.22.2.json
 delete mode 100644 references/posthog-python-references-7.22.3.json
 delete mode 100644 references/posthog-python-references-7.23.0.json
 delete mode 100644 references/posthog-python-references-7.24.0.json
 delete mode 100644 references/posthog-python-references-7.25.0.json
 delete mode 100644 references/posthog-python-references-7.26.0.json
 delete mode 100644 references/posthog-python-references-7.27.0.json
 delete mode 100644 references/posthog-python-references-7.28.0.json
 delete mode 100644 references/posthog-python-references-7.29.0.json
 delete mode 100644 references/posthog-python-references-7.30.0.json
 delete mode 100644 references/posthog-python-references-7.30.1.json
 delete mode 100644 references/posthog-python-references-7.31.0.json
 delete mode 100644 references/posthog-python-references-7.31.1.json
 delete mode 100644 references/posthog-python-references-7.32.0.json
 delete mode 100644 references/posthog-python-references-7.33.0.json
 delete mode 100644 references/posthog-python-references-7.34.0.json
 delete mode 100644 references/posthog-python-references-7.35.0.json
 delete mode 100644 references/posthog-python-references-7.35.1.json
 delete mode 100644 references/posthog-python-references-7.35.2.json
 delete mode 100644 references/posthog-python-references-7.35.3.json
 delete mode 100644 references/posthog-python-references-7.35.4.json
 delete mode 100644 references/posthog-python-references-7.35.5.json
 delete mode 100644 references/posthog-python-references-7.36.0.json
 delete mode 100644 references/posthog-python-references-7.37.0.json
 delete mode 100644 references/posthog-python-references-7.37.1.json
 delete mode 100644 references/posthog-python-references-7.37.2.json
 delete mode 100644 references/posthog-python-references-7.37.3.json
 delete mode 100644 references/posthog-python-references-7.37.4.json
 delete mode 100644 references/posthog-python-references-7.37.5.json
 delete mode 100644 references/posthog-python-references-7.37.6.json
 delete mode 100644 references/posthog-python-references-7.38.0.json
 delete mode 100644 references/posthog-python-references-7.38.1.json
 delete mode 100644 references/posthog-python-references-7.38.2.json
 delete mode 100644 references/posthog-python-references-7.38.3.json
 delete mode 100644 references/posthog-python-references-7.38.4.json
 delete mode 100644 references/posthog-python-references-7.38.5.json
 delete mode 100644 references/posthog-python-references-7.38.6.json
 delete mode 100644 references/posthog-python-references-7.39.0.json
 delete mode 100644 references/posthog-python-references-7.39.1.json
 delete mode 100644 references/posthog-python-references-7.40.0.json
 delete mode 100644 references/posthog-python-references-7.41.0.json
 delete mode 100644 references/posthog-python-references-7.42.0.json
 delete mode 100644 references/posthog-python-references-7.42.1.json
 delete mode 100644 references/posthog-python-references-7.43.0.json
 delete mode 100644 references/posthog-python-references-7.44.0.json
 delete mode 100644 references/posthog-python-references-7.44.1.json
 delete mode 100644 references/posthog-python-references-7.44.2.json
 delete mode 100644 references/posthog-python-references-7.45.0.json
 delete mode 100644 references/posthog-python-references-7.45.1.json
 delete mode 100644 references/posthog-python-references-7.45.2.json
 delete mode 100644 references/posthog-python-references-7.45.3.json
 delete mode 100644 references/posthog-python-references-7.46.0.json
 delete mode 100644 references/posthog-python-references-7.47.0.json
 delete mode 100644 references/posthog-python-references-7.47.1.json
 delete mode 100644 references/posthog-python-references-7.47.2.json
 delete mode 100644 references/posthog-python-references-7.47.3.json
 delete mode 100644 references/posthog-python-references-7.48.0.json
 delete mode 100644 references/posthog-python-references-7.49.0.json
 delete mode 100644 references/posthog-python-references-7.50.0.json
 delete mode 100644 references/posthog-python-references-7.51.0.json
 delete mode 100644 references/posthog-python-references-7.51.1.json
 delete mode 100644 references/posthog-python-references-7.51.2.json
 delete mode 100644 references/posthog-python-references-7.52.0.json
 delete mode 100644 references/posthog-python-references-7.52.1.json
 delete mode 100644 references/posthog-python-references-7.53.0.json
 delete mode 100644 references/posthog-python-references-7.54.0.json
 delete mode 100644 references/posthog-python-references-7.54.1.json
 delete mode 100644 references/posthog-python-references-7.54.2.json
 delete mode 100644 references/posthog-python-references-7.55.0.json
 delete mode 100644 references/posthog-python-references-7.56.0.json
 delete mode 100644 references/posthog-python-references-7.57.0.json
 delete mode 100644 references/posthog-python-references-7.58.0.json
 delete mode 100644 references/posthog-python-references-7.59.0.json
 delete mode 100644 references/posthog-python-references-7.59.1.json
 delete mode 100644 references/posthog-python-references-7.59.2.json
 delete mode 100644 references/posthog-python-references-7.60.0.json
 delete mode 100644 references/posthog-python-references-7.60.1.json
 delete mode 100644 references/posthog-python-references-7.61.0.json
 delete mode 100644 references/posthog-python-references-7.61.1.json
 delete mode 100644 references/posthog-python-references-7.62.0.json
 delete mode 100644 references/posthog-python-references-7.62.1.json
 delete mode 100644 references/posthog-python-references-7.63.0.json
 delete mode 100644 references/posthog-python-references-7.64.0.json
 delete mode 100644 references/posthog-python-references-7.64.1.json
 delete mode 100644 references/posthog-python-references-7.66.0.json
 delete mode 100644 references/posthog-python-references-7.67.0.json
 delete mode 100644 references/posthog-python-references-7.67.1.json
 delete mode 100644 references/posthog-python-references-7.68.0.json
 delete mode 100644 references/posthog-python-references-7.69.0.json
 delete mode 100644 references/posthog-python-references-7.70.0.json
 delete mode 100644 references/posthog-python-references-7.70.1.json
 delete mode 100644 references/posthog-python-references-7.70.2.json
 delete mode 100644 references/posthog-python-references-7.72.0.json
 delete mode 100644 references/posthog-python-references-7.73.0.json
 delete mode 100644 references/posthog-python-references-7.73.1.json
 delete mode 100644 references/posthog-python-references-7.73.2.json
 delete mode 100644 references/posthog-python-references-7.73.3.json
 delete mode 100644 references/posthog-python-references-7.74.0.json
 delete mode 100644 references/posthog-python-references-7.75.0.json
 delete mode 100644 references/posthog-python-references-7.75.1.json
 delete mode 100644 references/posthog-python-references-7.75.10.json
 delete mode 100644 references/posthog-python-references-7.75.2.json
 delete mode 100644 references/posthog-python-references-7.75.3.json
 delete mode 100644 references/posthog-python-references-7.75.4.json
 delete mode 100644 references/posthog-python-references-7.75.5.json
 delete mode 100644 references/posthog-python-references-7.75.6.json
 delete mode 100644 references/posthog-python-references-7.75.7.json
 delete mode 100644 references/posthog-python-references-7.75.8.json
 delete mode 100644 references/posthog-python-references-7.75.9.json
 delete mode 100644 references/posthog-python-references-7.76.0.json
 delete mode 100644 references/posthog-python-references-7.76.1.json
 delete mode 100644 references/posthog-python-references-7.77.0.json
 delete mode 100644 references/posthog-python-references-7.78.0.json
 delete mode 100644 references/posthog-python-references-7.79.0.json
 delete mode 100644 references/posthog-python-references-7.80.0.json
 delete mode 100644 references/posthog-python-references-7.80.1.json
 delete mode 100644 references/posthog-python-references-7.80.2.json
 delete mode 100644 references/posthog-python-references-7.80.3.json
 delete mode 100644 references/posthog-python-references-7.81.0.json
 delete mode 100644 references/posthog-python-references-7.81.1.json
 delete mode 100644 references/posthog-python-references-7.82.0.json
 delete mode 100644 references/posthog-python-references-7.82.1.json
 delete mode 100644 references/posthog-python-references-7.82.2.json
 delete mode 100644 references/posthog-python-references-7.83.0.json
 delete mode 100644 references/posthog-python-references-7.83.1.json
 delete mode 100644 references/posthog-python-references-7.83.2.json
 delete mode 100644 references/posthog-python-references-7.84.0.json
 delete mode 100644 references/posthog-python-references-7.84.1.json
 delete mode 100644 references/posthog-python-references-7.84.2.json
 delete mode 100644 references/posthog-python-references-7.85.0.json
 delete mode 100644 references/posthog-python-references-7.86.0.json
 delete mode 100644 references/posthog-python-references-7.86.1.json
 delete mode 100644 references/posthog-python-references-7.86.2.json
 delete mode 100644 references/posthog-python-references-7.86.3.json
 delete mode 100644 references/posthog-python-references-7.86.4.json
 delete mode 100644 references/posthog-python-references-7.86.5.json

diff --git a/references/posthog-python-references-6.7.10.json b/references/posthog-python-references-6.7.10.json
deleted file mode 100644
index 4fde4a5f9..000000000
--- a/references/posthog-python-references-6.7.10.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.7.10",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.7.11.json b/references/posthog-python-references-6.7.11.json
deleted file mode 100644
index 0ac5a7dc0..000000000
--- a/references/posthog-python-references-6.7.11.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.7.11",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.7.12.json b/references/posthog-python-references-6.7.12.json
deleted file mode 100644
index c4769c2eb..000000000
--- a/references/posthog-python-references-6.7.12.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.7.12",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.7.13.json b/references/posthog-python-references-6.7.13.json
deleted file mode 100644
index 6b0c973bf..000000000
--- a/references/posthog-python-references-6.7.13.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.7.13",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.7.7.json b/references/posthog-python-references-6.7.7.json
deleted file mode 100644
index 3c24b7463..000000000
--- a/references/posthog-python-references-6.7.7.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.7.7",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.8.0.json b/references/posthog-python-references-6.8.0.json
deleted file mode 100644
index 57c9ab156..000000000
--- a/references/posthog-python-references-6.8.0.json
+++ /dev/null
@@ -1,2343 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.8.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.9.0.json b/references/posthog-python-references-6.9.0.json
deleted file mode 100644
index 2b534b2d4..000000000
--- a/references/posthog-python-references-6.9.0.json
+++ /dev/null
@@ -1,2430 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.9.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.capture(\n    'event_name',\n    distinct_id='user-distinct-id',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            },
-            {
-              "id": "example_2",
-              "name": "Set using context",
-              "code": "# Set using context\nfrom posthog import new_context, identify_context\nwith new_context():\n    identify_context('user-distinct-id')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.9.1.json b/references/posthog-python-references-6.9.1.json
deleted file mode 100644
index eb26f3aec..000000000
--- a/references/posthog-python-references-6.9.1.json
+++ /dev/null
@@ -1,2425 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.9.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-6.9.2.json b/references/posthog-python-references-6.9.2.json
deleted file mode 100644
index f1a1625d6..000000000
--- a/references/posthog-python-references-6.9.2.json
+++ /dev/null
@@ -1,2425 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "6.9.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.0.0.json b/references/posthog-python-references-7.0.0.json
deleted file mode 100644
index 53d2ccdb2..000000000
--- a/references/posthog-python-references-7.0.0.json
+++ /dev/null
@@ -1,2425 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.0.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.0.1.json b/references/posthog-python-references-7.0.1.json
deleted file mode 100644
index fc608f585..000000000
--- a/references/posthog-python-references-7.0.1.json
+++ /dev/null
@@ -1,2425 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.0.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user by calling decide.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.14.0.json b/references/posthog-python-references-7.14.0.json
deleted file mode 100644
index 955b57dd4..000000000
--- a/references/posthog-python-references-7.14.0.json
+++ /dev/null
@@ -1,2725 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.14.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.14.1.json b/references/posthog-python-references-7.14.1.json
deleted file mode 100644
index 2dd4000c1..000000000
--- a/references/posthog-python-references-7.14.1.json
+++ /dev/null
@@ -1,2725 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.14.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.15.0.json b/references/posthog-python-references-7.15.0.json
deleted file mode 100644
index 988ba4105..000000000
--- a/references/posthog-python-references-7.15.0.json
+++ /dev/null
@@ -1,2725 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.15.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "The project API key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "The host to use for the client.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Whether to enable debug mode.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled  Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled:     # Use the variant and payload     print(f\"Variant: {result.variant}\")     print(f\"Payload: {result.payload}\") ```",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Set whether code variables are captured for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Variable names matching these patterns will be ignored completely when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Variable names matching these patterns will be masked with *** when capturing code variables.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import capture\ncapture(\n    'distinct_id',\n    event='event_name',\n    properties={\n        '$set': {'name': 'Max Hedgehog'},\n        '$set_once': {'initial_url': '/blog'}\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.15.1.json b/references/posthog-python-references-7.15.1.json
deleted file mode 100644
index 0977aaa79..000000000
--- a/references/posthog-python-references-7.15.1.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.15.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance.  Raises:     ValueError: If ``api_key`` has not been configured.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.15.3.json b/references/posthog-python-references-7.15.3.json
deleted file mode 100644
index e75be17ec..000000000
--- a/references/posthog-python-references-7.15.3.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.15.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance.  Raises:     ValueError: If ``api_key`` has not been configured.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.15.4.json b/references/posthog-python-references-7.15.4.json
deleted file mode 100644
index a659d92e1..000000000
--- a/references/posthog-python-references-7.15.4.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.15.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance.  Raises:     ValueError: If ``api_key`` has not been configured.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.16.0.json b/references/posthog-python-references-7.16.0.json
deleted file mode 100644
index b56a23512..000000000
--- a/references/posthog-python-references-7.16.0.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.16.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance.  Raises:     ValueError: If ``api_key`` has not been configured.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.16.1.json b/references/posthog-python-references-7.16.1.json
deleted file mode 100644
index 62220ced4..000000000
--- a/references/posthog-python-references-7.16.1.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.16.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance.  Raises:     ValueError: If ``api_key`` has not been configured.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.16.2.json b/references/posthog-python-references-7.16.2.json
deleted file mode 100644
index 2fc1c0bbe..000000000
--- a/references/posthog-python-references-7.16.2.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.16.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.16.3.json b/references/posthog-python-references-7.16.3.json
deleted file mode 100644
index 48408c622..000000000
--- a/references/posthog-python-references-7.16.3.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.16.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.16.4.json b/references/posthog-python-references-7.16.4.json
deleted file mode 100644
index fea4c0708..000000000
--- a/references/posthog-python-references-7.16.4.json
+++ /dev/null
@@ -1,2912 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.16.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.17.0.json b/references/posthog-python-references-7.17.0.json
deleted file mode 100644
index 18b1d67ff..000000000
--- a/references/posthog-python-references-7.17.0.json
+++ /dev/null
@@ -1,2918 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.17.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.18.0.json b/references/posthog-python-references-7.18.0.json
deleted file mode 100644
index 9f690ab24..000000000
--- a/references/posthog-python-references-7.18.0.json
+++ /dev/null
@@ -1,2918 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.18.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.18.1.json b/references/posthog-python-references-7.18.1.json
deleted file mode 100644
index 3e6ffe884..000000000
--- a/references/posthog-python-references-7.18.1.json
+++ /dev/null
@@ -1,2924 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.18.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.18.2.json b/references/posthog-python-references-7.18.2.json
deleted file mode 100644
index 3f06fd7e3..000000000
--- a/references/posthog-python-references-7.18.2.json
+++ /dev/null
@@ -1,2924 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.18.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.18.3.json b/references/posthog-python-references-7.18.3.json
deleted file mode 100644
index e3e8c526a..000000000
--- a/references/posthog-python-references-7.18.3.json
+++ /dev/null
@@ -1,2924 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.18.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.19.0.json b/references/posthog-python-references-7.19.0.json
deleted file mode 100644
index efe2ea4bc..000000000
--- a/references/posthog-python-references-7.19.0.json
+++ /dev/null
@@ -1,2948 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.19.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.19.1.json b/references/posthog-python-references-7.19.1.json
deleted file mode 100644
index 153a5a63d..000000000
--- a/references/posthog-python-references-7.19.1.json
+++ /dev/null
@@ -1,2948 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.19.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.19.2.json b/references/posthog-python-references-7.19.2.json
deleted file mode 100644
index d7130b76f..000000000
--- a/references/posthog-python-references-7.19.2.json
+++ /dev/null
@@ -1,2948 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.19.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Optional[str]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context.",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with posthog.new_context():\n    identify_context('<distinct_id>')\n    posthog.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking (default: True)",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.0.json b/references/posthog-python-references-7.20.0.json
deleted file mode 100644
index e192cb541..000000000
--- a/references/posthog-python-references-7.20.0.json
+++ /dev/null
@@ -1,3093 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.1.json b/references/posthog-python-references-7.20.1.json
deleted file mode 100644
index b1e79399d..000000000
--- a/references/posthog-python-references-7.20.1.json
+++ /dev/null
@@ -1,3093 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "dict[str, str]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, FeatureFlag]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlag]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "any"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.2.json b/references/posthog-python-references-7.20.2.json
deleted file mode 100644
index 289a7a6b2..000000000
--- a/references/posthog-python-references-7.20.2.json
+++ /dev/null
@@ -1,3120 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.3.json b/references/posthog-python-references-7.20.3.json
deleted file mode 100644
index 428eace96..000000000
--- a/references/posthog-python-references-7.20.3.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.4.json b/references/posthog-python-references-7.20.4.json
deleted file mode 100644
index b27b6d731..000000000
--- a/references/posthog-python-references-7.20.4.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.20.5.json b/references/posthog-python-references-7.20.5.json
deleted file mode 100644
index 0c562d176..000000000
--- a/references/posthog-python-references-7.20.5.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.20.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.21.0.json b/references/posthog-python-references-7.21.0.json
deleted file mode 100644
index 426559d05..000000000
--- a/references/posthog-python-references-7.21.0.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.21.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.21.1.json b/references/posthog-python-references-7.21.1.json
deleted file mode 100644
index 7225b2655..000000000
--- a/references/posthog-python-references-7.21.1.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.21.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.21.2.json b/references/posthog-python-references-7.21.2.json
deleted file mode 100644
index 0c13d2ee4..000000000
--- a/references/posthog-python-references-7.21.2.json
+++ /dev/null
@@ -1,3147 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.21.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Personal API key used for local feature flag         evaluation and remote config payloads.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.22.0.json b/references/posthog-python-references-7.22.0.json
deleted file mode 100644
index 984f0031a..000000000
--- a/references/posthog-python-references-7.22.0.json
+++ /dev/null
@@ -1,3171 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.22.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.22.1.json b/references/posthog-python-references-7.22.1.json
deleted file mode 100644
index 8f9331e06..000000000
--- a/references/posthog-python-references-7.22.1.json
+++ /dev/null
@@ -1,3171 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.22.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.22.2.json b/references/posthog-python-references-7.22.2.json
deleted file mode 100644
index 2f96528c5..000000000
--- a/references/posthog-python-references-7.22.2.json
+++ /dev/null
@@ -1,3171 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.22.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.22.3.json b/references/posthog-python-references-7.22.3.json
deleted file mode 100644
index 3ccdb4b72..000000000
--- a/references/posthog-python-references-7.22.3.json
+++ /dev/null
@@ -1,3171 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.22.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.23.0.json b/references/posthog-python-references-7.23.0.json
deleted file mode 100644
index 108cd0372..000000000
--- a/references/posthog-python-references-7.23.0.json
+++ /dev/null
@@ -1,3177 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.23.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.24.0.json b/references/posthog-python-references-7.24.0.json
deleted file mode 100644
index d7e4768f0..000000000
--- a/references/posthog-python-references-7.24.0.json
+++ /dev/null
@@ -1,3182 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.24.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.25.0.json b/references/posthog-python-references-7.25.0.json
deleted file mode 100644
index 059f926d3..000000000
--- a/references/posthog-python-references-7.25.0.json
+++ /dev/null
@@ -1,3182 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.25.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.26.0.json b/references/posthog-python-references-7.26.0.json
deleted file mode 100644
index cc182d019..000000000
--- a/references/posthog-python-references-7.26.0.json
+++ /dev/null
@@ -1,3182 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.26.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.27.0.json b/references/posthog-python-references-7.27.0.json
deleted file mode 100644
index a13cd7843..000000000
--- a/references/posthog-python-references-7.27.0.json
+++ /dev/null
@@ -1,3192 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.27.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.28.0.json b/references/posthog-python-references-7.28.0.json
deleted file mode 100644
index 329a0c61b..000000000
--- a/references/posthog-python-references-7.28.0.json
+++ /dev/null
@@ -1,3192 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.28.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "_dedicated_ai_endpoint",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.29.0.json b/references/posthog-python-references-7.29.0.json
deleted file mode 100644
index 3485eeacb..000000000
--- a/references/posthog-python-references-7.29.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.29.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.30.0.json b/references/posthog-python-references-7.30.0.json
deleted file mode 100644
index 4a63f4e84..000000000
--- a/references/posthog-python-references-7.30.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.30.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.30.1.json b/references/posthog-python-references-7.30.1.json
deleted file mode 100644
index 0f78e5991..000000000
--- a/references/posthog-python-references-7.30.1.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.30.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.31.0.json b/references/posthog-python-references-7.31.0.json
deleted file mode 100644
index 8cba1982d..000000000
--- a/references/posthog-python-references-7.31.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.31.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If ``api_key`` is missing or blank,     the client is disabled and module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.31.1.json b/references/posthog-python-references-7.31.1.json
deleted file mode 100644
index 1d2185e8f..000000000
--- a/references/posthog-python-references-7.31.1.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.31.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.32.0.json b/references/posthog-python-references-7.32.0.json
deleted file mode 100644
index e11a57573..000000000
--- a/references/posthog-python-references-7.32.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.32.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.33.0.json b/references/posthog-python-references-7.33.0.json
deleted file mode 100644
index f8dddd8b4..000000000
--- a/references/posthog-python-references-7.33.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.33.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.34.0.json b/references/posthog-python-references-7.34.0.json
deleted file mode 100644
index 7308572bb..000000000
--- a/references/posthog-python-references-7.34.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.34.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.0.json b/references/posthog-python-references-7.35.0.json
deleted file mode 100644
index 0ea813726..000000000
--- a/references/posthog-python-references-7.35.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.1.json b/references/posthog-python-references-7.35.1.json
deleted file mode 100644
index 594840b1d..000000000
--- a/references/posthog-python-references-7.35.1.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.2.json b/references/posthog-python-references-7.35.2.json
deleted file mode 100644
index 04aab81d6..000000000
--- a/references/posthog-python-references-7.35.2.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries for background consumers.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.3.json b/references/posthog-python-references-7.35.3.json
deleted file mode 100644
index 40fd41b48..000000000
--- a/references/posthog-python-references-7.35.3.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.4.json b/references/posthog-python-references-7.35.4.json
deleted file mode 100644
index c5ed26a1d..000000000
--- a/references/posthog-python-references-7.35.4.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.35.5.json b/references/posthog-python-references-7.35.5.json
deleted file mode 100644
index 94d16f2bd..000000000
--- a/references/posthog-python-references-7.35.5.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.35.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.36.0.json b/references/posthog-python-references-7.36.0.json
deleted file mode 100644
index 08127cc8d..000000000
--- a/references/posthog-python-references-7.36.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.36.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.0.json b/references/posthog-python-references-7.37.0.json
deleted file mode 100644
index ca128b50d..000000000
--- a/references/posthog-python-references-7.37.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.1.json b/references/posthog-python-references-7.37.1.json
deleted file mode 100644
index 9bbe272ed..000000000
--- a/references/posthog-python-references-7.37.1.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.2.json b/references/posthog-python-references-7.37.2.json
deleted file mode 100644
index 64ffa4dcb..000000000
--- a/references/posthog-python-references-7.37.2.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.3.json b/references/posthog-python-references-7.37.3.json
deleted file mode 100644
index 6a7f390c5..000000000
--- a/references/posthog-python-references-7.37.3.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.4.json b/references/posthog-python-references-7.37.4.json
deleted file mode 100644
index 0298ee673..000000000
--- a/references/posthog-python-references-7.37.4.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.5.json b/references/posthog-python-references-7.37.5.json
deleted file mode 100644
index ab837be14..000000000
--- a/references/posthog-python-references-7.37.5.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.37.6.json b/references/posthog-python-references-7.37.6.json
deleted file mode 100644
index 92cb13c95..000000000
--- a/references/posthog-python-references-7.37.6.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.37.6",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.0.json b/references/posthog-python-references-7.38.0.json
deleted file mode 100644
index b53245e81..000000000
--- a/references/posthog-python-references-7.38.0.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "End the consumer thread once the queue is empty. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.1.json b/references/posthog-python-references-7.38.1.json
deleted file mode 100644
index 35ea28a2d..000000000
--- a/references/posthog-python-references-7.38.1.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team').",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.2.json b/references/posthog-python-references-7.38.2.json
deleted file mode 100644
index 42cd80c84..000000000
--- a/references/posthog-python-references-7.38.2.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.3.json b/references/posthog-python-references-7.38.3.json
deleted file mode 100644
index 89da44c60..000000000
--- a/references/posthog-python-references-7.38.3.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.4.json b/references/posthog-python-references-7.38.4.json
deleted file mode 100644
index 708f6fda9..000000000
--- a/references/posthog-python-references-7.38.4.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.5.json b/references/posthog-python-references-7.38.5.json
deleted file mode 100644
index 887b6bc9e..000000000
--- a/references/posthog-python-references-7.38.5.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.38.6.json b/references/posthog-python-references-7.38.6.json
deleted file mode 100644
index 4809ea70c..000000000
--- a/references/posthog-python-references-7.38.6.json
+++ /dev/null
@@ -1,3198 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.38.6",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.39.0.json b/references/posthog-python-references-7.39.0.json
deleted file mode 100644
index 849c00af4..000000000
--- a/references/posthog-python-references-7.39.0.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.39.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event",
-              "isOptional": true,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.39.1.json b/references/posthog-python-references-7.39.1.json
deleted file mode 100644
index 02096e1f2..000000000
--- a/references/posthog-python-references-7.39.1.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.39.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.40.0.json b/references/posthog-python-references-7.40.0.json
deleted file mode 100644
index 58058b3a5..000000000
--- a/references/posthog-python-references-7.40.0.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.40.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.41.0.json b/references/posthog-python-references-7.41.0.json
deleted file mode 100644
index 7957579be..000000000
--- a/references/posthog-python-references-7.41.0.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.41.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.42.0.json b/references/posthog-python-references-7.42.0.json
deleted file mode 100644
index 800c0fee5..000000000
--- a/references/posthog-python-references-7.42.0.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.42.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.42.1.json b/references/posthog-python-references-7.42.1.json
deleted file mode 100644
index 57708a35d..000000000
--- a/references/posthog-python-references-7.42.1.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.42.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys to scope the underlying ``/flags``         request to a subset.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list of flag keys. When provided, only these flags are         evaluated \u2014 the underlying ``/flags`` request asks the server for just         this subset, which makes the response smaller and the request cheaper.         Use this when you only need a handful of flags out of many.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.43.0.json b/references/posthog-python-references-7.43.0.json
deleted file mode 100644
index 5c9341ab2..000000000
--- a/references/posthog-python-references-7.43.0.json
+++ /dev/null
@@ -1,3265 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.43.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional non-empty list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. An empty list is treated like         ``None`` and evaluates all flags. A requested key absent from loaded local         definitions is included in one remote fallback per ``evaluate_flags`` call unless         ``only_evaluate_locally`` is True. If the server also does not know the key, it is         omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional non-empty list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. An empty list is treated like ``None``         and evaluates all flags. A requested key absent from loaded local definitions is         included in one remote fallback per ``evaluate_flags`` call unless         ``only_evaluate_locally`` is ``True``. If the server also does not know the key, it is         omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.44.0.json b/references/posthog-python-references-7.44.0.json
deleted file mode 100644
index 371cd8024..000000000
--- a/references/posthog-python-references-7.44.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.44.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.44.1.json b/references/posthog-python-references-7.44.1.json
deleted file mode 100644
index e9583854b..000000000
--- a/references/posthog-python-references-7.44.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.44.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.44.2.json b/references/posthog-python-references-7.44.2.json
deleted file mode 100644
index 25e2ebad6..000000000
--- a/references/posthog-python-references-7.44.2.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.44.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.45.0.json b/references/posthog-python-references-7.45.0.json
deleted file mode 100644
index b38b5cf01..000000000
--- a/references/posthog-python-references-7.45.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.45.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.45.1.json b/references/posthog-python-references-7.45.1.json
deleted file mode 100644
index 9123b7a2c..000000000
--- a/references/posthog-python-references-7.45.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.45.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.45.2.json b/references/posthog-python-references-7.45.2.json
deleted file mode 100644
index f5ccfd05f..000000000
--- a/references/posthog-python-references-7.45.2.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.45.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.45.3.json b/references/posthog-python-references-7.45.3.json
deleted file mode 100644
index ac56bef2b..000000000
--- a/references/posthog-python-references-7.45.3.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.45.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.46.0.json b/references/posthog-python-references-7.46.0.json
deleted file mode 100644
index 757e8a844..000000000
--- a/references/posthog-python-references-7.46.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.46.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.47.0.json b/references/posthog-python-references-7.47.0.json
deleted file mode 100644
index e55b6dabe..000000000
--- a/references/posthog-python-references-7.47.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.47.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.47.1.json b/references/posthog-python-references-7.47.1.json
deleted file mode 100644
index f6ff73d3b..000000000
--- a/references/posthog-python-references-7.47.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.47.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.47.2.json b/references/posthog-python-references-7.47.2.json
deleted file mode 100644
index e3c0c7714..000000000
--- a/references/posthog-python-references-7.47.2.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.47.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.47.3.json b/references/posthog-python-references-7.47.3.json
deleted file mode 100644
index 63185a41c..000000000
--- a/references/posthog-python-references-7.47.3.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.47.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.48.0.json b/references/posthog-python-references-7.48.0.json
deleted file mode 100644
index 1ab66c2f9..000000000
--- a/references/posthog-python-references-7.48.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.48.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.49.0.json b/references/posthog-python-references-7.49.0.json
deleted file mode 100644
index 0535e0a7b..000000000
--- a/references/posthog-python-references-7.49.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.49.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.50.0.json b/references/posthog-python-references-7.50.0.json
deleted file mode 100644
index 3203eed36..000000000
--- a/references/posthog-python-references-7.50.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.50.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.51.0.json b/references/posthog-python-references-7.51.0.json
deleted file mode 100644
index 5237d8f7e..000000000
--- a/references/posthog-python-references-7.51.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.51.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.51.1.json b/references/posthog-python-references-7.51.1.json
deleted file mode 100644
index 484dcb8c2..000000000
--- a/references/posthog-python-references-7.51.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.51.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.51.2.json b/references/posthog-python-references-7.51.2.json
deleted file mode 100644
index 8dc52610e..000000000
--- a/references/posthog-python-references-7.51.2.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.51.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.52.0.json b/references/posthog-python-references-7.52.0.json
deleted file mode 100644
index a8841b991..000000000
--- a/references/posthog-python-references-7.52.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.52.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.52.1.json b/references/posthog-python-references-7.52.1.json
deleted file mode 100644
index 6421dacad..000000000
--- a/references/posthog-python-references-7.52.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.52.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.53.0.json b/references/posthog-python-references-7.53.0.json
deleted file mode 100644
index d2ebbed95..000000000
--- a/references/posthog-python-references-7.53.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.53.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.54.0.json b/references/posthog-python-references-7.54.0.json
deleted file mode 100644
index 122987642..000000000
--- a/references/posthog-python-references-7.54.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.54.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.54.1.json b/references/posthog-python-references-7.54.1.json
deleted file mode 100644
index 31ab85e19..000000000
--- a/references/posthog-python-references-7.54.1.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.54.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.54.2.json b/references/posthog-python-references-7.54.2.json
deleted file mode 100644
index 125311000..000000000
--- a/references/posthog-python-references-7.54.2.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.54.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.55.0.json b/references/posthog-python-references-7.55.0.json
deleted file mode 100644
index d8ef677de..000000000
--- a/references/posthog-python-references-7.55.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.55.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.56.0.json b/references/posthog-python-references-7.56.0.json
deleted file mode 100644
index 7298fcada..000000000
--- a/references/posthog-python-references-7.56.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.56.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.57.0.json b/references/posthog-python-references-7.57.0.json
deleted file mode 100644
index 2db1e9faf..000000000
--- a/references/posthog-python-references-7.57.0.json
+++ /dev/null
@@ -1,3271 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.57.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.58.0.json b/references/posthog-python-references-7.58.0.json
deleted file mode 100644
index 7717dea2f..000000000
--- a/references/posthog-python-references-7.58.0.json
+++ /dev/null
@@ -1,3436 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.58.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.59.0.json b/references/posthog-python-references-7.59.0.json
deleted file mode 100644
index a5ad32157..000000000
--- a/references/posthog-python-references-7.59.0.json
+++ /dev/null
@@ -1,3436 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.59.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.59.1.json b/references/posthog-python-references-7.59.1.json
deleted file mode 100644
index 5a71e0bf1..000000000
--- a/references/posthog-python-references-7.59.1.json
+++ /dev/null
@@ -1,3436 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.59.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.59.2.json b/references/posthog-python-references-7.59.2.json
deleted file mode 100644
index c3a3678d8..000000000
--- a/references/posthog-python-references-7.59.2.json
+++ /dev/null
@@ -1,3436 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.59.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.60.0.json b/references/posthog-python-references-7.60.0.json
deleted file mode 100644
index f02c72de5..000000000
--- a/references/posthog-python-references-7.60.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.60.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.60.1.json b/references/posthog-python-references-7.60.1.json
deleted file mode 100644
index b9c5ba4aa..000000000
--- a/references/posthog-python-references-7.60.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.60.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.61.0.json b/references/posthog-python-references-7.61.0.json
deleted file mode 100644
index ed444a7ea..000000000
--- a/references/posthog-python-references-7.61.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.61.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.61.1.json b/references/posthog-python-references-7.61.1.json
deleted file mode 100644
index 2120a9f3f..000000000
--- a/references/posthog-python-references-7.61.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.61.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.62.0.json b/references/posthog-python-references-7.62.0.json
deleted file mode 100644
index 151cec4dd..000000000
--- a/references/posthog-python-references-7.62.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.62.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.62.1.json b/references/posthog-python-references-7.62.1.json
deleted file mode 100644
index 23d891d60..000000000
--- a/references/posthog-python-references-7.62.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.62.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.63.0.json b/references/posthog-python-references-7.63.0.json
deleted file mode 100644
index 9444d858b..000000000
--- a/references/posthog-python-references-7.63.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.63.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.64.0.json b/references/posthog-python-references-7.64.0.json
deleted file mode 100644
index 1ee12f3db..000000000
--- a/references/posthog-python-references-7.64.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.64.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.64.1.json b/references/posthog-python-references-7.64.1.json
deleted file mode 100644
index a3912a89e..000000000
--- a/references/posthog-python-references-7.64.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.64.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.66.0.json b/references/posthog-python-references-7.66.0.json
deleted file mode 100644
index 2f919329f..000000000
--- a/references/posthog-python-references-7.66.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.66.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.67.0.json b/references/posthog-python-references-7.67.0.json
deleted file mode 100644
index 600acb877..000000000
--- a/references/posthog-python-references-7.67.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.67.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.67.1.json b/references/posthog-python-references-7.67.1.json
deleted file mode 100644
index 69955559b..000000000
--- a/references/posthog-python-references-7.67.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.67.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.68.0.json b/references/posthog-python-references-7.68.0.json
deleted file mode 100644
index ef12885a8..000000000
--- a/references/posthog-python-references-7.68.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.68.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.69.0.json b/references/posthog-python-references-7.69.0.json
deleted file mode 100644
index d407afdb1..000000000
--- a/references/posthog-python-references-7.69.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.69.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.70.0.json b/references/posthog-python-references-7.70.0.json
deleted file mode 100644
index 6e46c32c7..000000000
--- a/references/posthog-python-references-7.70.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.70.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.70.1.json b/references/posthog-python-references-7.70.1.json
deleted file mode 100644
index affb9655a..000000000
--- a/references/posthog-python-references-7.70.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.70.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.70.2.json b/references/posthog-python-references-7.70.2.json
deleted file mode 100644
index 598946836..000000000
--- a/references/posthog-python-references-7.70.2.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.70.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Force a flush from the internal queue to the server. Do not use directly, call `shutdown()` instead.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.         Queued spans are sent at the same time, within the same",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name')\nposthog.flush()  # Ensures the event is sent immediately"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client. Call this before the process ends in serverless environments to avoid data loss.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Queued spans get one final flush of up to 30 s (plus a request already in flight); any it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Tell the client to flush all queued events.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Maximum seconds to wait for the queue to flush.         Defaults to 10 seconds. Pass ``None`` to wait indefinitely.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import flush\nflush()"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Flush all messages and cleanly shutdown the client.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.72.0.json b/references/posthog-python-references-7.72.0.json
deleted file mode 100644
index 05421adfc..000000000
--- a/references/posthog-python-references-7.72.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.72.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.73.0.json b/references/posthog-python-references-7.73.0.json
deleted file mode 100644
index 9e6844b34..000000000
--- a/references/posthog-python-references-7.73.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.73.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.73.1.json b/references/posthog-python-references-7.73.1.json
deleted file mode 100644
index 9c588f586..000000000
--- a/references/posthog-python-references-7.73.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.73.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.73.2.json b/references/posthog-python-references-7.73.2.json
deleted file mode 100644
index 0df272044..000000000
--- a/references/posthog-python-references-7.73.2.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.73.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.73.3.json b/references/posthog-python-references-7.73.3.json
deleted file mode 100644
index 973a24408..000000000
--- a/references/posthog-python-references-7.73.3.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.73.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.74.0.json b/references/posthog-python-references-7.74.0.json
deleted file mode 100644
index 2053aac41..000000000
--- a/references/posthog-python-references-7.74.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.74.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.0.json b/references/posthog-python-references-7.75.0.json
deleted file mode 100644
index 23d13e277..000000000
--- a/references/posthog-python-references-7.75.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.1.json b/references/posthog-python-references-7.75.1.json
deleted file mode 100644
index 738621f18..000000000
--- a/references/posthog-python-references-7.75.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.10.json b/references/posthog-python-references-7.75.10.json
deleted file mode 100644
index 226ca01c2..000000000
--- a/references/posthog-python-references-7.75.10.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.10",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.2.json b/references/posthog-python-references-7.75.2.json
deleted file mode 100644
index 6b0cdcdf1..000000000
--- a/references/posthog-python-references-7.75.2.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.3.json b/references/posthog-python-references-7.75.3.json
deleted file mode 100644
index 03f87f17f..000000000
--- a/references/posthog-python-references-7.75.3.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.4.json b/references/posthog-python-references-7.75.4.json
deleted file mode 100644
index 2cd75278e..000000000
--- a/references/posthog-python-references-7.75.4.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.5.json b/references/posthog-python-references-7.75.5.json
deleted file mode 100644
index 342f66487..000000000
--- a/references/posthog-python-references-7.75.5.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.6.json b/references/posthog-python-references-7.75.6.json
deleted file mode 100644
index ecbda11e3..000000000
--- a/references/posthog-python-references-7.75.6.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.6",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.7.json b/references/posthog-python-references-7.75.7.json
deleted file mode 100644
index e6b6c343b..000000000
--- a/references/posthog-python-references-7.75.7.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.7",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.8.json b/references/posthog-python-references-7.75.8.json
deleted file mode 100644
index bacd9eaf2..000000000
--- a/references/posthog-python-references-7.75.8.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.8",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.75.9.json b/references/posthog-python-references-7.75.9.json
deleted file mode 100644
index 3ced9019c..000000000
--- a/references/posthog-python-references-7.75.9.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.75.9",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.76.0.json b/references/posthog-python-references-7.76.0.json
deleted file mode 100644
index 9df82cc58..000000000
--- a/references/posthog-python-references-7.76.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.76.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.76.1.json b/references/posthog-python-references-7.76.1.json
deleted file mode 100644
index 966c6f297..000000000
--- a/references/posthog-python-references-7.76.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.76.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.77.0.json b/references/posthog-python-references-7.77.0.json
deleted file mode 100644
index 70871253b..000000000
--- a/references/posthog-python-references-7.77.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.77.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.78.0.json b/references/posthog-python-references-7.78.0.json
deleted file mode 100644
index 66be86ee2..000000000
--- a/references/posthog-python-references-7.78.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.78.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are simply omitted from the snapshot.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.79.0.json b/references/posthog-python-references-7.79.0.json
deleted file mode 100644
index a58eca355..000000000
--- a/references/posthog-python-references-7.79.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.79.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.80.0.json b/references/posthog-python-references-7.80.0.json
deleted file mode 100644
index cecc19693..000000000
--- a/references/posthog-python-references-7.80.0.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.80.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.80.1.json b/references/posthog-python-references-7.80.1.json
deleted file mode 100644
index 841a5b2d4..000000000
--- a/references/posthog-python-references-7.80.1.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.80.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.80.2.json b/references/posthog-python-references-7.80.2.json
deleted file mode 100644
index d8cd45066..000000000
--- a/references/posthog-python-references-7.80.2.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.80.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.80.3.json b/references/posthog-python-references-7.80.3.json
deleted file mode 100644
index 8ee9a06c2..000000000
--- a/references/posthog-python-references-7.80.3.json
+++ /dev/null
@@ -1,3548 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.80.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.81.0.json b/references/posthog-python-references-7.81.0.json
deleted file mode 100644
index 7c2dd117a..000000000
--- a/references/posthog-python-references-7.81.0.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.81.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.81.1.json b/references/posthog-python-references-7.81.1.json
deleted file mode 100644
index 2bbfeaef9..000000000
--- a/references/posthog-python-references-7.81.1.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.81.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.82.0.json b/references/posthog-python-references-7.82.0.json
deleted file mode 100644
index 8c1c04a60..000000000
--- a/references/posthog-python-references-7.82.0.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.82.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.82.1.json b/references/posthog-python-references-7.82.1.json
deleted file mode 100644
index c69506f46..000000000
--- a/references/posthog-python-references-7.82.1.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.82.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.82.2.json b/references/posthog-python-references-7.82.2.json
deleted file mode 100644
index 39752929b..000000000
--- a/references/posthog-python-references-7.82.2.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.82.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "int",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "int",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.83.0.json b/references/posthog-python-references-7.83.0.json
deleted file mode 100644
index ea89d2637..000000000
--- a/references/posthog-python-references-7.83.0.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.83.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.83.1.json b/references/posthog-python-references-7.83.1.json
deleted file mode 100644
index a2d0c5a3e..000000000
--- a/references/posthog-python-references-7.83.1.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.83.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.83.2.json b/references/posthog-python-references-7.83.2.json
deleted file mode 100644
index 8962f1f55..000000000
--- a/references/posthog-python-references-7.83.2.json
+++ /dev/null
@@ -1,3566 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.83.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.84.0.json b/references/posthog-python-references-7.84.0.json
deleted file mode 100644
index d02a4ee15..000000000
--- a/references/posthog-python-references-7.84.0.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.84.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.84.1.json b/references/posthog-python-references-7.84.1.json
deleted file mode 100644
index 0da4e84b5..000000000
--- a/references/posthog-python-references-7.84.1.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.84.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.84.2.json b/references/posthog-python-references-7.84.2.json
deleted file mode 100644
index 26ee3007a..000000000
--- a/references/posthog-python-references-7.84.2.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.84.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.85.0.json b/references/posthog-python-references-7.85.0.json
deleted file mode 100644
index 8d26a3229..000000000
--- a/references/posthog-python-references-7.85.0.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.85.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.0.json b/references/posthog-python-references-7.86.0.json
deleted file mode 100644
index 7b9ca3f88..000000000
--- a/references/posthog-python-references-7.86.0.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.0",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.1.json b/references/posthog-python-references-7.86.1.json
deleted file mode 100644
index 687877368..000000000
--- a/references/posthog-python-references-7.86.1.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.1",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.2.json b/references/posthog-python-references-7.86.2.json
deleted file mode 100644
index 3caf38994..000000000
--- a/references/posthog-python-references-7.86.2.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.2",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.3.json b/references/posthog-python-references-7.86.3.json
deleted file mode 100644
index 2ed52742a..000000000
--- a/references/posthog-python-references-7.86.3.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.3",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.4.json b/references/posthog-python-references-7.86.4.json
deleted file mode 100644
index 587faa0ba..000000000
--- a/references/posthog-python-references-7.86.4.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.4",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file
diff --git a/references/posthog-python-references-7.86.5.json b/references/posthog-python-references-7.86.5.json
deleted file mode 100644
index 9ad33f5ee..000000000
--- a/references/posthog-python-references-7.86.5.json
+++ /dev/null
@@ -1,3572 +0,0 @@
-{
-  "id": "posthog-python",
-  "hogRef": "0.3",
-  "info": {
-    "version": "7.86.5",
-    "id": "posthog-python",
-    "title": "PostHog Python SDK",
-    "description": "Integrate PostHog into any python application.",
-    "slugPrefix": "posthog-python",
-    "specUrl": "https://github.com/PostHog/posthog-python"
-  },
-  "types": [
-    {
-      "id": "FeatureFlag",
-      "name": "FeatureFlag",
-      "path": "posthog.types.FeatureFlag",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[FlagReason]",
-          "description": "Field: reason"
-        },
-        {
-          "name": "metadata",
-          "type": "Union[FlagMetadata, LegacyFlagMetadata]",
-          "description": "Field: metadata"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FeatureFlagResult",
-      "name": "FeatureFlagResult",
-      "path": "posthog.types.FeatureFlagResult",
-      "properties": [
-        {
-          "name": "key",
-          "type": "str",
-          "description": "Field: key"
-        },
-        {
-          "name": "enabled",
-          "type": "bool",
-          "description": "Field: enabled"
-        },
-        {
-          "name": "variant",
-          "type": "Optional[str]",
-          "description": "Field: variant"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[Any]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "reason",
-          "type": "Optional[str]",
-          "description": "Field: reason"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagMetadata",
-      "name": "FlagMetadata",
-      "path": "posthog.types.FlagMetadata",
-      "properties": [
-        {
-          "name": "id",
-          "type": "Optional[int]",
-          "description": "Field: id"
-        },
-        {
-          "name": "payload",
-          "type": "Optional[str]",
-          "description": "Field: payload"
-        },
-        {
-          "name": "version",
-          "type": "Optional[int]",
-          "description": "Field: version"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        },
-        {
-          "name": "has_experiment",
-          "type": "Optional[bool]",
-          "description": "Field: has_experiment"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagReason",
-      "name": "FlagReason",
-      "path": "posthog.types.FlagReason",
-      "properties": [
-        {
-          "name": "code",
-          "type": "str",
-          "description": "Field: code"
-        },
-        {
-          "name": "condition_index",
-          "type": "Optional[int]",
-          "description": "Field: condition_index"
-        },
-        {
-          "name": "description",
-          "type": "str",
-          "description": "Field: description"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsAndPayloads",
-      "name": "FlagsAndPayloads",
-      "path": "posthog.types.FlagsAndPayloads",
-      "properties": [
-        {
-          "name": "featureFlags",
-          "type": "Optional[dict[str, Union[bool, str]]]",
-          "description": "Field: featureFlags"
-        },
-        {
-          "name": "featureFlagPayloads",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: featureFlagPayloads"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "FlagsResponse",
-      "name": "FlagsResponse",
-      "path": "posthog.types.FlagsResponse",
-      "properties": [
-        {
-          "name": "flags",
-          "type": "dict[str, FeatureFlag]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "errorsWhileComputingFlags",
-          "type": "bool",
-          "description": "Field: errorsWhileComputingFlags"
-        },
-        {
-          "name": "requestId",
-          "type": "str",
-          "description": "Field: requestId"
-        },
-        {
-          "name": "quotaLimit",
-          "type": "Optional[list[str]]",
-          "description": "Field: quotaLimit"
-        },
-        {
-          "name": "evaluatedAt",
-          "type": "Optional[int]",
-          "description": "Field: evaluatedAt"
-        },
-        {
-          "name": "minimalFlagCalledEvents",
-          "type": "bool",
-          "description": "Field: minimalFlagCalledEvents"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "LegacyFlagMetadata",
-      "name": "LegacyFlagMetadata",
-      "path": "posthog.types.LegacyFlagMetadata",
-      "properties": [
-        {
-          "name": "payload",
-          "type": "Any",
-          "description": "Field: payload"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalCaptureArgs",
-      "name": "OptionalCaptureArgs",
-      "path": "posthog.args.OptionalCaptureArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "groups",
-          "type": "NotRequired[Optional[dict[str, str]]]",
-          "description": "Field: groups"
-        },
-        {
-          "name": "flags",
-          "type": "NotRequired[Optional[ForwardRef('FeatureFlagEvaluations')]]",
-          "description": "Field: flags"
-        },
-        {
-          "name": "send_feature_flags",
-          "type": "NotRequired[Union[bool, SendFeatureFlagsOptions, any]]",
-          "description": "Field: send_feature_flags"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        },
-        {
-          "name": "_property_allowlist",
-          "type": "NotRequired[Optional[frozenset[str]]]",
-          "description": "Field: _property_allowlist"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "OptionalSetArgs",
-      "name": "OptionalSetArgs",
-      "path": "posthog.args.OptionalSetArgs",
-      "properties": [
-        {
-          "name": "distinct_id",
-          "type": "NotRequired[Union[Number, str, UUID, int, any]]",
-          "description": "Field: distinct_id"
-        },
-        {
-          "name": "properties",
-          "type": "NotRequired[Optional[dict[str, Any]]]",
-          "description": "Field: properties"
-        },
-        {
-          "name": "timestamp",
-          "type": "NotRequired[Union[datetime, str, any]]",
-          "description": "Field: timestamp"
-        },
-        {
-          "name": "uuid",
-          "type": "NotRequired[Union[str, UUID, any]]",
-          "description": "Field: uuid"
-        },
-        {
-          "name": "disable_geoip",
-          "type": "NotRequired[Optional[bool]]",
-          "description": "Field: disable_geoip"
-        }
-      ],
-      "example": ""
-    },
-    {
-      "id": "SendFeatureFlagsOptions",
-      "name": "SendFeatureFlagsOptions",
-      "path": "posthog.types.SendFeatureFlagsOptions",
-      "properties": [
-        {
-          "name": "should_send",
-          "type": "bool",
-          "description": "Field: should_send"
-        },
-        {
-          "name": "only_evaluate_locally",
-          "type": "Optional[bool]",
-          "description": "Field: only_evaluate_locally"
-        },
-        {
-          "name": "person_properties",
-          "type": "Optional[dict[str, Any]]",
-          "description": "Field: person_properties"
-        },
-        {
-          "name": "group_properties",
-          "type": "Optional[dict[str, dict[str, Any]]]",
-          "description": "Field: group_properties"
-        },
-        {
-          "name": "flag_keys_filter",
-          "type": "Optional[list[str]]",
-          "description": "Field: flag_keys_filter"
-        }
-      ],
-      "example": ""
-    }
-  ],
-  "classes": [
-    {
-      "id": "PostHog",
-      "title": "PostHog",
-      "description": "This is the SDK reference for the PostHog Python SDK. You can learn more about example usage in the [Python SDK documentation](/docs/libraries/python). You can also follow [Flask](/docs/libraries/flask) and [Django](/docs/libraries/django) guides to integrate PostHog into your project.  For long-running applications, create one client during application startup and reuse it for the lifetime of the process. This keeps background queues predictable and makes shutdown flushing straightforward. Multiple clients are still supported for intentional multi-project or multi-host setups.",
-      "functions": [
-        {
-          "id": "__init__",
-          "title": "Client",
-          "description": "Initialize a new PostHog client instance.",
-          "details": "",
-          "category": "Initialization",
-          "params": [
-            {
-              "name": "project_api_key",
-              "description": "PostHog project API key/token.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "host",
-              "description": "PostHog host. Defaults to the US ingestion endpoint when not         set. App hosts such as ``https://us.posthog.com`` are mapped to         the corresponding ingestion host.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "debug",
-              "description": "Enable verbose SDK logging and re-raise errors from public         API methods.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_queue_size",
-              "description": "Maximum number of events buffered before upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "send",
-              "description": "If False, queueing succeeds but events are not sent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "on_error",
-              "description": "Optional callback invoked by background consumers when an         upload fails. Keep it short and non-blocking. Calling lifecycle         methods directly is safe and deferred, but do not start another         thread or task that calls ``flush()``, ``join()``, or         ``shutdown()`` and then wait for it from the callback.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flush_at",
-              "description": "Number of queued events that triggers a batch upload.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "flush_interval",
-              "description": "Maximum seconds a background consumer waits before         flushing a partial batch.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "gzip",
-              "description": "Whether to gzip event upload payloads.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "max_retries",
-              "description": "Number of upload retries. Values below 0 are treated as 0.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "sync_mode",
-              "description": "If True, send each event synchronously instead of using         background worker threads. This blocks the calling thread; in         asyncio applications such as FastAPI, use ``AsyncPosthog``         instead.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "timeout",
-              "description": "HTTP request timeout in seconds for event uploads.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "thread",
-              "description": "Number of background consumer threads.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "poll_interval",
-              "description": "Seconds between local feature flag definition refreshes.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "personal_api_key",
-              "description": "Deprecated alias for ``secret_key``. Still honored         for backwards compatibility; prefer ``secret_key``, which also         accepts a Project Secret API Key.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "disabled",
-              "description": "If True, disable captures and API requests. Useful in tests.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable server-side GeoIP enrichment.         Defaults to True.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "is_server",
-              "description": "Whether events are emitted from a server-side runtime.         Defaults to True; set to False when using the SDK as a client/CLI         so the device OS is attributed to the person normally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "historical_migration",
-              "description": "Mark events as historical migration imports.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "feature_flags_request_timeout_seconds",
-              "description": "Timeout in seconds for feature         flag and remote config requests.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "feature_flags_request_max_retries",
-              "description": "Number of retries for feature flag         requests after network, transport, or timeout failures. Defaults         to 1. Set to 0 to disable retries.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "super_properties",
-              "description": "Properties merged into every captured event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_exception_autocapture",
-              "description": "Automatically capture uncaught         exceptions.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "log_captured_exceptions",
-              "description": "Also log exceptions captured by error         tracking.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "project_root",
-              "description": "Root path used to determine in-app stack frames for         captured exceptions. Defaults to the current working directory.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "privacy_mode",
-              "description": "For AI observability, capture usage metadata without         prompt inputs or outputs.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "before_send",
-              "description": "Optional callback that can modify or drop events before         upload. Return ``None`` to drop an event.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "flag_fallback_cache_url",
-              "description": "Optional feature flag fallback cache URL,         such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "enable_local_evaluation",
-              "description": "Whether to poll feature flag definitions for         local evaluation when a personal API key is configured.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "flag_definition_cache_provider",
-              "description": "Optional external cache provider for         sharing feature flag definitions across workers.",
-              "isOptional": true,
-              "type": "FlagDefinitionCacheProvider"
-            },
-            {
-              "name": "capture_exception_code_variables",
-              "description": "Capture local variable values on         exception stack frames.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "code_variables_mask_patterns",
-              "description": "Variable-name patterns to mask when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_ignore_patterns",
-              "description": "Variable-name patterns to omit when         capturing code variables.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_mask_url_credentials",
-              "description": "Scrub credentials embedded in         URLs/DSNs (e.g. ``user:pass@host``) from captured code variables,         regardless of the surrounding variable name. Defaults to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "code_variables_detect_secrets",
-              "description": "Last-resort entropy-based detection that         redacts high-entropy secret-looking values (API keys, tokens, strong         passwords) sitting in innocuously-named variables, after the name and         URL checks. Skips structured ids (UUIDs, ObjectIds, hashes). Defaults         to True.",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "in_app_modules",
-              "description": "Module/package prefixes treated as in-app frames in         captured exceptions.",
-              "isOptional": false,
-              "type": "UnionType[list[str], any]"
-            },
-            {
-              "name": "enable_exception_autocapture_rate_limiting",
-              "description": "Rate limit         autocaptured exceptions client-side with a token bucket per         exception type. Disabled by default.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "exception_autocapture_bucket_size",
-              "description": "Maximum burst of autocaptured         exceptions allowed per exception type (token bucket size,         clamped to 0-100).",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_rate",
-              "description": "Tokens restored per refill         interval for each exception type's bucket.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "exception_autocapture_refill_interval_seconds",
-              "description": "Seconds between         token refills for autocaptured exception rate limiting.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "capture_mode",
-              "description": "Capture wire protocol to use. Defaults to         ``CaptureMode.V0`` (legacy ``/batch/``). Set ``CaptureMode.V1``         (or pass the string ``\"v1\"``) to opt into         ``/i/v1/analytics/events``. When omitted, the         ``POSTHOG_CAPTURE_MODE`` env var is consulted, then ``V0``.",
-              "isOptional": false,
-              "type": "CaptureMode"
-            },
-            {
-              "name": "capture_compression",
-              "description": "Request-body compression for capture-v1 uploads         (ignored in V0, which uses ``gzip``). ``CaptureCompression.GZIP``         or ``DEFLATE`` (or the strings ``\"gzip\"``/``\"deflate\"``). When         omitted, the ``POSTHOG_CAPTURE_COMPRESSION`` env var is consulted,         then the legacy ``gzip`` flag, then no compression.",
-              "isOptional": false,
-              "type": "CaptureCompression"
-            },
-            {
-              "name": "secret_key",
-              "description": "A Personal API Key or Project Secret API Key, used to         authenticate local feature flag evaluation, remote config         payloads, and decrypted flag payloads. Example::              posthog.Client(project_api_key, secret_key=\"phx_...\")",
-              "isOptional": false,
-              "type": "any"
-            },
-            {
-              "name": "metrics",
-              "description": "",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "enable_full_ai_capture",
-              "description": "Route PostHog AI wrapper events through         the dedicated AI capture endpoint and capture full AI content:         skips string truncation and passes media (base64/data URIs)         through unredacted. ``privacy_mode`` always wins. Defaults to         False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_trace_context",
-              "description": "When OpenTelemetry is installed and a valid span is         active at capture time, add its trace and span IDs as ``$trace_id`` and         ``$span_id`` properties to events captured with ``capture()`` and         ``capture_ai()``, so they can be correlated with backend traces. Explicit         ``$trace_id``/``$span_id`` values passed in ``properties`` win. Exception         events (``capture_exception``) always attach these IDs regardless of this         setting. Defaults to False.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_use_ai_lane",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "_enable_multimodal_capture",
-              "description": "",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "traces",
-              "description": "Config dict for distributed tracing: ``service_name``,         ``service_version``, ``environment``, ``resource_attributes``,         ``flush_interval`` (5 s), ``max_queue_size`` (2048),         ``max_export_batch_size`` (512), ``max_live_spans`` (10000),         ``max_span_age`` (3600 s), ``max_attributes_per_span`` (128),         ``max_events_per_span`` (128), ``max_attribute_value_length``         (8192). ``before_span_send`` is a callable, or a         list run in order, that receives each finished span as a dict         (``trace_id``, ``span_id`` and ``parent_span_id`` are read-only)         and returns it, edited, or ``None`` to drop it; a hook that         raises drops the span. Tracing is off until this is provided.         Spans export on a background timer even with ``sync_mode``;         serverless handlers should call ``flush()`` before returning.         Defaults to None.",
-              "isOptional": true,
-              "type": "dict"
-            },
-            {
-              "name": "app_host",
-              "description": "Your PostHog app host, such as ``https://posthog.example.com``.         ``emails`` sends there. Needed only when ``host`` is not PostHog         Cloud, for example a reverse proxy, which must not receive the         secret key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "email_request_timeout_seconds",
-              "description": "Timeout in seconds for each email send         request. Defaults to 15.",
-              "isOptional": false,
-              "type": "float"
-            },
-            {
-              "name": "email_request_max_retries",
-              "description": "Number of retries for an email send after a         network error, a rate limit, or an unavailable service. Defaults to 2.         Set to 0 when a job runner already retries the send.",
-              "isOptional": false,
-              "type": "int"
-            },
-            {
-              "name": "migrated_from",
-              "description": "The email provider you moved from, such as         ``\"resend\"``. ``emails`` sends it with every request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import Posthog\n\nposthog = Posthog('<ph_project_api_key>', host='<ph_app_host>')"
-            }
-          ]
-        },
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Create an alias between two distinct IDs.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The previous distinct ID. Required - the call is dropped         with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The new distinct ID to alias to. Falls back to the         context distinct ID; the call is dropped with a warning if         neither is available.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.alias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Captures an event manually. [Learn about capture best practices](https://posthog.com/docs/product-analytics/capture-events)",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to capture.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Anonymous event",
-              "code": "# Anonymous event\nposthog.capture('some-anon-event')"
-            },
-            {
-              "id": "example_2",
-              "name": "Context usage",
-              "code": "# Context usage\nfrom posthog import identify_context, new_context\nwith new_context():\n    identify_context('distinct_id_of_the_user')\n    posthog.capture('user_signed_up')\n    posthog.capture('user_logged_in')\n    posthog.capture('some-custom-action', distinct_id='distinct_id_of_the_user')"
-            },
-            {
-              "id": "example_3",
-              "name": "Set event properties",
-              "code": "# Set event properties\nposthog.capture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            },
-            {
-              "id": "example_4",
-              "name": "Page view event",
-              "code": "# Page view event\nposthog.capture('$pageview', distinct_id=\"distinct_id_of_the_user\", properties={'$current_url': 'https://example.com'})"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is queued on an isolated AI lane with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Capture",
-          "params": [
-            {
-              "name": "event",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          }
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture an exception for error tracking.  When OpenTelemetry is installed and a valid span is active, its trace and span IDs are added as ``$trace_id`` and ``$span_id`` event properties.",
-          "details": "",
-          "category": "Error Tracking",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture.",
-              "isOptional": true,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "try:\n    # Some code that might fail\n    pass\nexcept Exception as e:\n    posthog.capture_exception(e, 'user_distinct_id', properties=additional_properties)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to :meth:`capture` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.  Local evaluation is transparent: when the poller resolves a flag, the snapshot's ``$feature_flag_called`` events are tagged ``locally_evaluated=True`` and reason ``\"Evaluated locally\"``.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the         context distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If True, never fall back to remote evaluation \u2014         flags that can't be evaluated locally are omitted from the snapshot and         listed with a reason in its ``unresolved_flags``.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying         ``/flags`` request, and the returned snapshot. When omitted or ``None``, all         flags are evaluated. An empty list returns an empty snapshot without evaluating         flags. A requested key absent from loaded local definitions is included in one         remote fallback per ``evaluate_flags`` call unless ``only_evaluate_locally`` is         True. If the server also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flags = posthog.evaluate_flags(\n    \"user_123\",\n    person_properties={\"plan\": \"enterprise\"},\n)\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\nposthog.capture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Check if a feature flag is enabled for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Return feature flag definitions loaded for local evaluation.  Returns:     The currently loaded feature flag definitions, or ``None`` before     local evaluation has loaded definitions.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events, ended spans and autocaptured metrics, keeping the client reusable.  For a client shared across requests or serverless invocations (including the module-level client), call ``flush()`` before a short-lived invocation returns. Use ``shutdown()`` instead only for final process cleanup or when disposing of a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by the consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared         across event lanes. Defaults to 10 seconds. Pass ``None`` to wait         without a time limit; this does not guarantee successful delivery.         Queued spans flush concurrently. The span exporter waits up to         this many seconds for an in-flight flush, then uses a fresh drain         budget once it acquires the lock. If the lock wait times out, the         in-flight flush is left to finish. At least one span request is         attempted after acquiring the lock, even with no budget left;         retriable failures are retried after backoff while budget remains,         with one last attempt at the deadline. Each span request is         bounded by the client's ``timeout`` in         seconds, and the last request is not cut short. This is therefore         not a strict wall-clock limit for the whole call. With ``None``,         a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the shared client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all feature flags for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flags and their payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.get_all_flags_and_payloads('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get multivariate feature flag value for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nruntime = posthog.get_feature_flag_evaluation_runtime(\"my-flag\")\nif runtime is FeatureFlagEvaluationRuntime.SERVER:\n    ..."
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.  A flag set to ``FeatureFlagEvaluationRuntime.ALL`` suits either runtime, so it is returned for ``CLIENT`` and for ``SERVER``, and asking for ``ALL`` returns every loaded flag. Use this to decide which flags to hand to a browser when a backend serves flags to its own frontend.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "The runtime to match, as a         ``FeatureFlagEvaluationRuntime`` or its string value.",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime\n\nclient_keys = posthog.get_feature_flag_keys_by_evaluation_runtime(\n    FeatureFlagEvaluationRuntime.CLIENT\n)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload for a feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "The specific flag value to get payload for.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Deprecated. Use get_feature_flag() instead if you need events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')\n\nif is_my_flag_enabled:\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely depending on whether local evaluation is enabled and the flag can be locally evaluated. This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to only evaluate locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "flag_result = posthog.get_feature_flag_result('flag-key', 'distinct_id_of_your_user')\nif flag_result and flag_result.get_value() == 'variant-key':\n    # Do something differently for this user\n    # Optional: fetch the payload\n    matched_flag_payload = flag_result.payload"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flags_and_payloads",
-          "title": "get_feature_flags_and_payloads",
-          "description": "Get feature flags and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "result = posthog.get_feature_flags_and_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_payloads",
-          "title": "get_feature_payloads",
-          "description": "Get feature flag payloads for a user, preserving valid serialized JSON.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Optional[str]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "payloads = posthog.get_feature_payloads('<distinct_id>')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_variants",
-          "title": "get_feature_variants",
-          "description": "Get feature flag variants for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Union[bool, str]]"
-          }
-        },
-        {
-          "id": "get_flags_decision",
-          "title": "get_flags_decision",
-          "description": "Get feature flags decision.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "A dictionary of group information.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "A dictionary of person properties.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "A dictionary of group properties.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this request.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "A list of specific flag keys to evaluate. If provided,         only these flags will be evaluated, improving performance.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "The device ID for this request.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsResponse"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "decision = posthog.get_flags_decision('user123')"
-            }
-          ]
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The remote config feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Identify a group and set its properties.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "The type of group (e.g., 'company', 'team'). Required -         the call is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "The unique identifier for the group. Required - the call         is dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "A dictionary of properties to set on the group.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "The timestamp of the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "A unique identifier for the event. If provided, it must be a         valid UUID string or uuid.UUID instance; invalid values are         ignored and replaced with a newly generated UUID.",
-              "isOptional": false,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP for this event.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID of the user performing the action.",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.group_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and end the consumer threads. Do not use directly, call `shutdown()` instead.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.join()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flags for local evaluation.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.load_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context for managing shared state. Learn more about [contexts](/docs/libraries/python#contexts).",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "with client.new_context():\n    client.identify_context('<distinct_id>')\n    client.capture('event_name')"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the wrapped function using this client.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to create a fresh context that doesn't inherit from parent.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to automatically capture exceptions in this context. If omitted, defaults to this client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a person profile.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set with distinct id",
-              "code": "# Set with distinct id\nposthog.set(distinct_id='user123', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a person profile only if they haven't been set before.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.set_once(distinct_id='user123', properties={'initial_signup_date': '2024-01-01'})"
-            }
-          ]
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the client.  Call this for final process cleanup or when disposing of a client that will not be reused. It closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. Do not call it at the end of each request or serverless invocation when the client is shared; call ``flush()`` before returning instead. A shut-down client cannot be reused; create a new client if needed.  Normally this method blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get one final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Any spans it cannot send are discarded with a warning, as are spans still open. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. When called directly from an SDK callback such as ``on_error``, shutdown is deferred to avoid blocking the worker that invoked the callback. If the callback must coordinate a blocking shutdown, have it signal an application-owned thread and return before that thread calls shutdown. Do not wait inside the callback for another thread or task that calls a lifecycle method.",
-          "details": "",
-          "category": null,
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog.shutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer``         or ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header         value to continue a remote trace. Defaults to the active span.         A forked child starts with no active span; pass the parent         span to continue a trace across a fork.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "posthog = Posthog(\"<ph_project_api_key>\", traces={\"service_name\": \"checkout-api\"})\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value.",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          }
-        }
-      ]
-    },
-    {
-      "id": "PostHogModule",
-      "title": "PostHog Module Functions",
-      "description": "Global functions available in the PostHog module",
-      "functions": [
-        {
-          "id": "alias",
-          "title": "alias",
-          "description": "Associate user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "details": "To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like \"Which marketing channels leads to users churning after a month?\" or \"What do users do on our website before signing up?\". Particularly useful for associating user behaviour before and after they e.g. register, login, or perform some other identifying action.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "previous_id",
-              "description": "The unique ID of the user before",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The current unique id",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Alias user",
-              "code": "# Alias user\nfrom posthog import alias\nalias(previous_id='distinct_id', distinct_id='alias_id')"
-            }
-          ]
-        },
-        {
-          "id": "capture",
-          "title": "capture",
-          "description": "Capture anything a user does within your system.",
-          "details": "Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up. A capture call requires an event name to specify the event. We recommend using [verb] [noun], like `movie played` or `movie updated` to easily identify what your events mean later on. Capture takes a number of optional arguments, which are defined by the `OptionalCaptureArgs` type.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name to specify the event     **kwargs: Optional arguments including:",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Context and capture usage",
-              "code": "# Context and capture usage\nfrom posthog import new_context, identify_context, tag_context, capture\n# Enter a new context (e.g. a request/response cycle, an instance of a background job, etc)\nwith new_context():\n    # Associate this context with some user, by distinct_id\n    identify_context('some user')\n\n    # Capture an event, associated with the context-level distinct ID ('some user')\n    capture('movie started')\n\n    # Capture an event associated with some other user (overriding the context-level distinct ID)\n    capture('movie joined', distinct_id='some-other-user')\n\n    # Capture an event with some properties\n    capture('movie played', properties={'movie_id': '123', 'category': 'romcom'})\n\n    # Capture an event with some properties\n    capture('purchase', properties={'product_id': '123', 'category': 'romcom'})\n    # Capture an event with some associated group\n    capture('purchase', groups={'company': 'id:5'})\n\n    # Adding a tag to the current context will cause it to appear on all subsequent events\n    tag_context('some-tag', 'some-value')\n\n    capture('another-event') # Will be captured with `'some-tag': 'some-value'` in the properties dict"
-            },
-            {
-              "id": "example_2",
-              "name": "Set event properties",
-              "code": "# Set event properties\nfrom posthog import capture\ncapture(\n    \"user_signed_up\",\n    distinct_id=\"distinct_id_of_the_user\",\n    properties={\n        \"login_type\": \"email\",\n        \"is_free_trial\": \"true\"\n    }\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_ai",
-          "title": "capture_ai",
-          "description": "Capture an AI event on the dedicated AI capture endpoint.  Beta: the signature is stable; operational limits (per-event size cap, batching, endpoint) may change without notice.  Takes the same arguments and returns the same value as `capture()`: the event UUID, or None when the event was not admitted (disabled client, or dropped by `before_send`). The event is delivered on an isolated queue with its own consumer pool and a higher per-event size cap, posting to the dedicated AI ingestion endpoint. The payload is sent as given \u2014 no redaction or truncation is applied here.",
-          "details": "",
-          "category": "Events",
-          "params": [
-            {
-              "name": "event",
-              "description": "The event name, normally one of the `$ai_*` event names.     **kwargs: Same optional arguments as `capture()`.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import capture_ai\n\nuuid = capture_ai(\n    \"$ai_generation\",\n    distinct_id=\"user_123\",\n    properties={\"$ai_model\": \"gpt-5\"},\n)"
-            }
-          ]
-        },
-        {
-          "id": "capture_exception",
-          "title": "capture_exception",
-          "description": "Capture exceptions that happen in your code.",
-          "details": "Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the \"traceback\"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError(\"Some Error\"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`.",
-          "category": "Events",
-          "params": [
-            {
-              "name": "exception",
-              "description": "The exception to capture. If not provided, the current exception is captured via `sys.exc_info()`     **kwargs: Optional capture arguments including distinct_id, properties,         timestamp, uuid, groups, flags, send_feature_flags, and disable_geoip.         Overriding reserved exception properties through ``properties`` is         deprecated and will stop working in the next major version.",
-              "isOptional": false,
-              "type": "BaseException"
-            },
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalCaptureArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Capture exception",
-              "code": "# Capture exception\nfrom posthog import capture_exception\ntry:\n    risky_operation()\nexcept Exception as e:\n    capture_exception(e)"
-            }
-          ]
-        },
-        {
-          "id": "evaluate_flags",
-          "title": "evaluate_flags",
-          "description": "Evaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on.  Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` \u2014 it consolidates flag evaluation into a single ``/flags`` request per incoming request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID. If ``None``, falls back to the context         distinct_id. If still unresolvable, returns an empty snapshot.",
-              "isOptional": false,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "If ``True``, never fall back to remote evaluation and         omit flags that cannot be evaluated locally. The snapshot's         ``unresolved_flags`` lists them with a reason.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "flag_keys",
-              "description": "Optional list that scopes local evaluation, the underlying ``/flags``         request, and the returned snapshot. When omitted or ``None``, all flags are evaluated.         An empty list returns an empty snapshot without evaluating flags. A requested key         absent from loaded local definitions is included in one remote fallback per         ``evaluate_flags`` call unless ``only_evaluate_locally`` is ``True``. If the server         also does not know the key, it is omitted from the snapshot.",
-              "isOptional": true,
-              "type": "list[str]"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override. If not provided, falls back to the         context device_id (which may be set via tracing headers). Used by         experience-continuity flags to match users across distinct_id changes.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FeatureFlagEvaluations"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import evaluate_flags, capture\nflags = evaluate_flags(\"user_123\", person_properties={\"plan\": \"enterprise\"})\nif flags.is_enabled(\"new-dashboard\"):\n    render_new_dashboard()\ncapture(\"page_viewed\", distinct_id=\"user_123\", flags=flags)"
-            }
-          ]
-        },
-        {
-          "id": "feature_enabled",
-          "title": "feature_enabled",
-          "description": "Use feature flags to enable or disable features for users.",
-          "details": "You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[bool]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Boolean feature flag",
-              "code": "# Boolean feature flag\nfrom posthog import feature_enabled, get_feature_flag_payload\nis_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user')\nif is_my_flag_enabled:\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "feature_flag_definitions",
-          "title": "feature_flag_definitions",
-          "description": "Returns loaded feature flags.",
-          "details": "Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded.",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import feature_flag_definitions\ndefinitions = feature_flag_definitions()"
-            }
-          ]
-        },
-        {
-          "id": "flush",
-          "title": "flush",
-          "description": "Attempt immediate delivery of queued events and ended spans, keeping the global client reusable.  Call ``flush()`` before a short-lived request or serverless invocation returns when using the shared module-level client. Use ``shutdown()`` only for final process cleanup or a client that will not be reused. Flush does not stop the background workers or feature flag poller, and does not end open spans.  Returning does not guarantee server receipt: pending work can remain after a timeout or span export failure, and failed events may be dropped by consumers. Calls made directly from SDK callbacks such as ``on_error`` are deferred rather than blocking the worker that invoked the callback.",
-          "details": "",
-          "category": "Client management",
-          "params": [
-            {
-              "name": "timeout_seconds",
-              "description": "Seconds to wait for event queues to drain, shared across         event lanes. Defaults to 10 seconds. Pass ``None`` to wait without a         time limit; this does not guarantee successful delivery. Queued spans         flush concurrently, waiting up to this many seconds for an in-flight         flush before starting a fresh drain budget. A lock wait timeout leaves         the in-flight flush to finish. At least one span request is attempted         after acquiring the lock, even with no budget left; retriable failures         are retried after backoff while budget remains, with one last attempt         at the deadline. The last span request is not cut short and is bounded         by the client's ``timeout`` in seconds,         so this is not a strict wall-clock limit for the whole call. With         ``None``, a retriable span failure is left for a later flush rather than         retried within this call.",
-              "isOptional": true,
-              "type": "float"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.capture('event_name', distinct_id='user_id')\n# Before a serverless invocation returns; keep the global client open.\nposthog.flush(timeout_seconds=10)"
-            }
-          ]
-        },
-        {
-          "id": "get_active_span",
-          "title": "get_active_span",
-          "description": "The span that is active in the current context, or ``None``. Alpha.  Only entering a span (``with posthog.start_span(...) as span:``) makes it active; a span started manually is not. Use it to propagate the trace to the next service: ``span.traceparent()`` is the header value.",
-          "details": "",
-          "category": "Tracing",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[Span]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "span = posthog.get_active_span()\nif span is not None:\n    headers[\"traceparent\"] = span.traceparent()"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags",
-          "title": "get_all_flags",
-          "description": "Get all flags for a given user.",
-          "details": "Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate (evaluates all if None)",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[dict[str, Union[bool, str]]]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "All flags for user",
-              "code": "# All flags for user\nfrom posthog import get_all_flags\nget_all_flags('distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_all_flags_and_payloads",
-          "title": "get_all_flags_and_payloads",
-          "description": "Get all feature flag values and payloads for a user.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "flag_keys_to_evaluate",
-              "description": "Optional list of flag keys to evaluate. Evaluates         all flags when omitted.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "FlagsAndPayloads"
-          }
-        },
-        {
-          "id": "get_feature_flag",
-          "title": "get_feature_flag",
-          "description": "Get feature flag variant for users. Used with experiments.",
-          "details": "`groups` are a mapping from group type to group key. So, if you have a group type of \"organization\" and a group key of \"5\", you would pass groups={\"organization\": \"5\"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type \"organization\" and the group key \"5\", with the properties name, and employee count, you'll send these as: group_properties={\"organization\": {\"name\": \"PostHog\", \"employees\": 11}}.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Groups mapping from group type to group key",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties in format { group_type_name: { group_properties } }",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send feature flag events",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Union[bool, str, any]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Multivariate feature flag",
-              "code": "# Multivariate feature flag\nfrom posthog import get_feature_flag, get_feature_flag_payload\nenabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user')\nif enabled_variant == 'variant-key':\n    matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_evaluation_runtime",
-          "title": "get_feature_flag_evaluation_runtime",
-          "description": "Return where a locally loaded feature flag is meant to be evaluated.",
-          "details": "Reads the `evaluation_runtime` each flag definition carries, so no extra     request is made. Returns `None` when local evaluation has not loaded a     definition for this key. A definition that carries no runtime reports     `FeatureFlagEvaluationRuntime.ALL`, the default PostHog applies.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagEvaluationRuntime]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_evaluation_runtime\nruntime = get_feature_flag_evaluation_runtime(\"my-flag\")"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_keys_by_evaluation_runtime",
-          "title": "get_feature_flag_keys_by_evaluation_runtime",
-          "description": "Return the keys of locally loaded flags that a runtime can evaluate.",
-          "details": "A flag set to `FeatureFlagEvaluationRuntime.ALL` suits either runtime, so     it is returned for `CLIENT` and for `SERVER`. Use this to decide which     flags to hand to a browser when a backend serves flags to its own     frontend.",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "evaluation_runtime",
-              "description": "",
-              "isOptional": true,
-              "type": "FeatureFlagEvaluationRuntime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "list[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import FeatureFlagEvaluationRuntime, get_feature_flag_keys_by_evaluation_runtime\nclient_keys = get_feature_flag_keys_by_evaluation_runtime(FeatureFlagEvaluationRuntime.CLIENT)"
-            }
-          ]
-        },
-        {
-          "id": "get_feature_flag_payload",
-          "title": "get_feature_flag_payload",
-          "description": "Get the payload associated with a feature flag value.  Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "match_value",
-              "description": "Optional flag value to use when selecting a payload.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[object]"
-          }
-        },
-        {
-          "id": "get_feature_flag_result",
-          "title": "get_feature_flag_result",
-          "description": "Get a FeatureFlagResult object which contains the flag result and payload.  This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The feature flag key.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "distinct_id",
-              "description": "The user's distinct ID.",
-              "isOptional": true,
-              "type": "Number"
-            },
-            {
-              "name": "groups",
-              "description": "Mapping of group type to group key.",
-              "isOptional": true,
-              "type": "Mapping[str, Union[str, int]]"
-            },
-            {
-              "name": "person_properties",
-              "description": "Person properties to use for evaluation.",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "group_properties",
-              "description": "Group properties keyed by group type.",
-              "isOptional": true,
-              "type": "dict[str, dict[str, Any]]"
-            },
-            {
-              "name": "only_evaluate_locally",
-              "description": "Whether to evaluate only locally.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "send_feature_flag_events",
-              "description": "Whether to send a $feature_flag_called event.",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "device_id",
-              "description": "Optional device ID override for experience-continuity flags.",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[FeatureFlagResult]"
-          }
-        },
-        {
-          "id": "get_remote_config_payload",
-          "title": "get_remote_config_payload",
-          "description": "Get the payload for a remote config feature flag.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "key",
-              "description": "The key of the feature flag",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "get_tags",
-          "title": "get_tags",
-          "description": "Get all tags from the current context.  Returns:     Dict of all tags in the current context",
-          "details": "",
-          "category": "Contexts",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "dict[str, Any]"
-          }
-        },
-        {
-          "id": "group_identify",
-          "title": "group_identify",
-          "description": "Set properties on a group.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "group_type",
-              "description": "Type of your group. Required - the call is dropped with a         warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "group_key",
-              "description": "Unique identifier of the group. Required - the call is         dropped with a warning if it is missing or empty.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "properties",
-              "description": "Properties to set on the group",
-              "isOptional": true,
-              "type": "dict[str, Any]"
-            },
-            {
-              "name": "timestamp",
-              "description": "Optional timestamp for the event. UTC is preferred; non-UTC         datetimes and parseable ISO timestamp strings are converted to UTC.",
-              "isOptional": false,
-              "type": "datetime"
-            },
-            {
-              "name": "uuid",
-              "description": "Optional UUID for the event",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "disable_geoip",
-              "description": "Whether to disable GeoIP lookup",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "distinct_id",
-              "description": "Optional distinct ID of the user performing the action",
-              "isOptional": false,
-              "type": "Number"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Group identify",
-              "code": "# Group identify\nfrom posthog import group_identify\ngroup_identify('company', 'company_id_in_your_db', {\n    'name': 'Awesome Inc.',\n    'employees': 11\n})"
-            }
-          ]
-        },
-        {
-          "id": "identify_context",
-          "title": "identify_context",
-          "description": "Identify the current context with a distinct ID.",
-          "details": "",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "distinct_id",
-              "description": "The distinct ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import identify_context\nidentify_context(\"user_123\")"
-            }
-          ]
-        },
-        {
-          "id": "join",
-          "title": "join",
-          "description": "Attempt to process queued events and stop the client's background workers. Use `shutdown()` directly in most cases.  Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import join\njoin()"
-            }
-          ]
-        },
-        {
-          "id": "load_feature_flags",
-          "title": "load_feature_flags",
-          "description": "Load feature flag definitions from PostHog.",
-          "details": "",
-          "category": "Feature flags",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import load_feature_flags\nload_feature_flags()"
-            }
-          ]
-        },
-        {
-          "id": "new_context",
-          "title": "new_context",
-          "description": "Create a new context scope that will be active for the duration of the with block.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture exceptions raised within the context. If omitted, defaults to the relevant client's exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            },
-            {
-              "name": "client",
-              "description": "Optional Posthog client instance to use for this context (default: None)",
-              "isOptional": true,
-              "type": "Client"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import new_context, tag, capture\nwith new_context():\n    tag(\"request_id\", \"123\")\n    capture(\"event_name\", properties={\"property\": \"value\"})"
-            }
-          ]
-        },
-        {
-          "id": "scoped",
-          "title": "scoped",
-          "description": "Decorator that creates a new context for the function.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "fresh",
-              "description": "Whether to start with a fresh context (default: False)",
-              "isOptional": false,
-              "type": "bool"
-            },
-            {
-              "name": "capture_exceptions",
-              "description": "Whether to capture and track exceptions with posthog error tracking. If omitted, defaults to the global exception autocapture setting.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import scoped, tag, capture\n@scoped()\ndef process_payment(payment_id):\n    tag(\"payment_id\", payment_id)\n    capture(\"payment_started\")"
-            }
-          ]
-        },
-        {
-          "id": "set",
-          "title": "set",
-          "description": "Set properties on a user record.",
-          "details": "This will overwrite previous people property values. Generally operates similar to `capture`, with distinct_id being an optional argument, defaulting to the current context's distinct ID. If there is no context-level distinct ID, and no override distinct_id is passed, this function will do nothing. Context tags are folded into $set properties, so tagging the current context and then calling `set` will cause those tags to be set on the user (unlike capture, which causes them to just be set on the event).",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set person properties",
-              "code": "# Set person properties\nfrom posthog import set\nset(distinct_id='distinct_id', properties={'name': 'Max Hedgehog'})"
-            }
-          ]
-        },
-        {
-          "id": "set_capture_exception_code_variables_context",
-          "title": "set_capture_exception_code_variables_context",
-          "description": "Override code-variable capture for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "Whether exceptions captured in this context should include local         variable values from stack frames.",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_detect_secrets_context",
-          "title": "set_code_variables_detect_secrets_context",
-          "description": "Whether to apply entropy-based secret detection as a last-resort redaction of high-entropy values (API keys, tokens, strong passwords) in captured code variables for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_ignore_patterns_context",
-          "title": "set_code_variables_ignore_patterns_context",
-          "description": "Override code-variable ignore patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "ignore_patterns",
-              "description": "Variable-name patterns that should be omitted entirely         when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_patterns_context",
-          "title": "set_code_variables_mask_patterns_context",
-          "description": "Override code-variable mask patterns for exceptions in the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "mask_patterns",
-              "description": "Variable-name patterns whose values should be replaced         with ``***`` when code variables are captured.",
-              "isOptional": true,
-              "type": "list[str]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_code_variables_mask_url_credentials_context",
-          "title": "set_code_variables_mask_url_credentials_context",
-          "description": "Whether to scrub credentials embedded in URLs/DSNs (e.g. user:pass@host) from captured code variables for the current context.",
-          "details": "",
-          "category": null,
-          "params": [
-            {
-              "name": "enabled",
-              "description": "",
-              "isOptional": true,
-              "type": "bool"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          }
-        },
-        {
-          "id": "set_context_device_id",
-          "title": "set_context_device_id",
-          "description": "Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "device_id",
-              "description": "The device ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_device_id\nset_context_device_id(\"device_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_context_session",
-          "title": "set_context_session",
-          "description": "Set the session ID for the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "session_id",
-              "description": "The session ID to associate with the current context and its children",
-              "isOptional": true,
-              "type": "str"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import set_context_session\nset_context_session(\"session_123\")"
-            }
-          ]
-        },
-        {
-          "id": "set_once",
-          "title": "set_once",
-          "description": "Set properties on a user record, only if they do not yet exist.",
-          "details": "This will not overwrite previous people property values, unlike `set`. Otherwise, operates in an identical manner to `set`.",
-          "category": "Identification",
-          "params": [
-            {
-              "name": "kwargs",
-              "description": "",
-              "isOptional": true,
-              "type": "Unpack[OptionalSetArgs]"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Optional[str]"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Set property once",
-              "code": "# Set property once\nfrom posthog import set_once\nset_once(distinct_id='distinct_id', properties={'initial_url': '/blog'})"
-            }
-          ]
-        },
-        {
-          "id": "setup",
-          "title": "setup",
-          "description": "Create or return the global PostHog client configured by module settings.  Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``.  Returns:     The global ``Client`` instance. If both ``api_key`` and     ``project_api_key`` are missing or blank, the client is disabled and     module-level calls become no-ops.",
-          "details": "",
-          "category": "Initialization",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Client"
-          }
-        },
-        {
-          "id": "shutdown",
-          "title": "shutdown",
-          "description": "Attempt final delivery and permanently shut down the global client.  Call this for final process cleanup, not at the end of each request or serverless invocation that shares the module-level client. Use ``flush()`` before returning from those invocations instead. Shutdown closes capture lanes, stops background workers and the feature flag poller, and tears down integrations. The global client is not recreated automatically after shutdown.  This normally blocks until queued events have been attempted and cleanup finishes. Failed or undrainable events may be dropped and reported through logging or ``on_error``; returning does not guarantee server receipt. Event draining has no timeout. Queued spans get a final flush with up to 30 seconds waiting for an in-flight flush, then a fresh 30-second drain budget; the last HTTP request is not cut short. Unsent queued spans and still-open spans are discarded with a warning. Lifecycle cleanup is attempted once, and cleanup failures are logged without retry. Calls made directly from SDK callbacks such as ``on_error`` are deferred to avoid deadlocking the worker. If blocking completion is required, signal an application-owned thread, return from the callback, and call ``shutdown()`` from that thread. Do not wait inside a callback for another thread or task calling a lifecycle method.",
-          "details": "",
-          "category": "Client management",
-          "params": [],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "any"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import shutdown\nshutdown()"
-            }
-          ]
-        },
-        {
-          "id": "start_span",
-          "title": "start_span",
-          "description": "Start a span for distributed tracing. Alpha.  Returns a span handle. Use it as a context manager to make it the active span for the block and end it on exit (recording a raised exception on the way out); or call ``end()`` yourself for a span that cannot wrap a block. Spans started inside the block nest under it automatically. Always returns a usable handle, even when tracing is off, so calling code never branches.",
-          "details": "",
-          "category": "Tracing",
-          "params": [
-            {
-              "name": "name",
-              "description": "A low-cardinality operation name, e.g. ``GET /users/:id``.         Variable values belong in attributes, not the name.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "kind",
-              "description": "``internal`` (default), ``server``, ``client``, ``producer`` or         ``consumer``.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "attributes",
-              "description": "Initial attributes.",
-              "isOptional": true,
-              "type": "Mapping[str, Any]"
-            },
-            {
-              "name": "parent",
-              "description": "A span handle, or an inbound W3C ``traceparent`` header value         to continue a remote trace. Defaults to the active span.",
-              "isOptional": false,
-              "type": "Span"
-            },
-            {
-              "name": "tracestate",
-              "description": "The inbound ``tracestate`` header accompanying a         ``traceparent`` string ``parent``; preserved and propagated.",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "start_time",
-              "description": "A ``datetime`` or epoch seconds, to backdate the span.",
-              "isOptional": false,
-              "type": "datetime"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "Span"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "import posthog\nposthog.traces = {\"service_name\": \"checkout-api\"}\n\nwith posthog.start_span(\"POST /checkout\", parent=request.headers.get(\"traceparent\")) as span:\n    span.set_attribute(\"plan\", user.plan)\n    with posthog.start_span(\"db.query\", kind=\"client\"):\n        ...\n    outgoing_headers = {\"traceparent\": span.traceparent()}"
-            }
-          ]
-        },
-        {
-          "id": "tag",
-          "title": "tag",
-          "description": "Add a tag to the current context.",
-          "details": "",
-          "category": "Contexts",
-          "params": [
-            {
-              "name": "name",
-              "description": "The tag key",
-              "isOptional": true,
-              "type": "str"
-            },
-            {
-              "name": "value",
-              "description": "The tag value",
-              "isOptional": true,
-              "type": "Any"
-            }
-          ],
-          "showDocs": true,
-          "releaseTag": "public",
-          "returnType": {
-            "id": "return_type",
-            "name": "None"
-          },
-          "examples": [
-            {
-              "id": "example_1",
-              "name": "Example 1",
-              "code": "from posthog import tag\ntag(\"user_id\", \"123\")"
-            }
-          ]
-        }
-      ]
-    }
-  ],
-  "categories": [
-    "Initialization",
-    "Identification",
-    "Capture",
-    "Error Tracking",
-    "Feature flags",
-    "Tracing",
-    "Contexts",
-    "Events",
-    "Client management"
-  ]
-}
\ No newline at end of file

From f66e696feb5835c0fd149e588b80db75a0674ce5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 11 Nov 2026 08:24:05 +0200
Subject: [PATCH 238/245] chore(deps): bump the uv group across 8 directories
 with 8 updates (#1222)

Bumps the uv group with 1 update in the /examples/example-ai-llamaindex directory: [nltk](https://github.com/nltk/nltk).
Bumps the uv group with 2 updates in the /examples/example-ai-crewai directory: [litellm](https://github.com/BerriAI/litellm) and [oauthlib](https://github.com/oauthlib/oauthlib).
Bumps the uv group with 4 updates in the /examples/example-ai-pydantic-ai directory: [authlib](https://github.com/authlib/authlib), [fastmcp](https://github.com/PrefectHQ/fastmcp), [joserfc](https://github.com/authlib/joserfc) and [pyasn1](https://github.com/pyasn1/pyasn1).
Bumps the uv group with 1 update in the /examples/example-ai-gemini directory: [pyasn1](https://github.com/pyasn1/pyasn1).
Bumps the uv group with 1 update in the /examples/example-ai-litellm directory: [litellm](https://github.com/BerriAI/litellm).
Bumps the uv group with 1 update in the /examples/example-ai-langgraph directory: [langgraph-sdk](https://github.com/langchain-ai/langgraph).
Bumps the uv group with 1 update in the /examples/example-ai-langchain directory: [langgraph-sdk](https://github.com/langchain-ai/langgraph).
Bumps the uv group with 1 update in the /examples/example-ai-dspy directory: [litellm](https://github.com/BerriAI/litellm).


Updates `nltk` from 3.10.3 to 3.10.4
- [Release notes](https://github.com/nltk/nltk/releases)
- [Changelog](https://github.com/nltk/nltk/blob/develop/ChangeLog)
- [Commits](https://github.com/nltk/nltk/compare/v3.10.3...v3.10.4)

Updates `litellm` from 1.88.6 to 1.100.4
- [Release notes](https://github.com/BerriAI/litellm/releases)
- [Commits](https://github.com/BerriAI/litellm/compare/v1.88.6...v1.100.4)

Updates `oauthlib` from 4.0.0 to 4.0.1
- [Release notes](https://github.com/oauthlib/oauthlib/releases)
- [Changelog](https://github.com/oauthlib/oauthlib/blob/v4.0.1/CHANGELOG.rst)
- [Commits](https://github.com/oauthlib/oauthlib/compare/v4.0.0...v4.0.1)

Updates `authlib` from 1.7.2 to 1.9.1
- [Release notes](https://github.com/authlib/authlib/releases)
- [Commits](https://github.com/authlib/authlib/compare/v1.7.2...v1.9.1)

Updates `fastmcp` from 3.4.2 to 3.4.10
- [Release notes](https://github.com/PrefectHQ/fastmcp/releases)
- [Changelog](https://github.com/PrefectHQ/fastmcp/blob/v3.4.10/docs/changelog.mdx)
- [Commits](https://github.com/PrefectHQ/fastmcp/compare/v3.4.2...v3.4.10)

Updates `joserfc` from 1.7.1 to 1.7.6
- [Release notes](https://github.com/authlib/joserfc/releases)
- [Changelog](https://github.com/authlib/joserfc/blob/main/docs/changelog.rst)
- [Commits](https://github.com/authlib/joserfc/compare/1.7.1...1.7.6)

Updates `pyasn1` from 0.6.4 to 0.6.5
- [Release notes](https://github.com/pyasn1/pyasn1/releases)
- [Changelog](https://github.com/pyasn1/pyasn1/blob/main/CHANGES.rst)
- [Commits](https://github.com/pyasn1/pyasn1/compare/v0.6.4...v0.6.5)

Updates `pyasn1` from 0.6.4 to 0.6.5
- [Release notes](https://github.com/pyasn1/pyasn1/releases)
- [Changelog](https://github.com/pyasn1/pyasn1/blob/main/CHANGES.rst)
- [Commits](https://github.com/pyasn1/pyasn1/compare/v0.6.4...v0.6.5)

Updates `litellm` from 1.88.6 to 1.100.4
- [Release notes](https://github.com/BerriAI/litellm/releases)
- [Commits](https://github.com/BerriAI/litellm/compare/v1.88.6...v1.100.4)

Updates `langgraph-sdk` from 0.4.4 to 0.4.6
- [Release notes](https://github.com/langchain-ai/langgraph/releases)
- [Commits](https://github.com/langchain-ai/langgraph/compare/0.4.4...0.4.6)

Updates `langgraph-sdk` from 0.4.4 to 0.4.12
- [Release notes](https://github.com/langchain-ai/langgraph/releases)
- [Commits](https://github.com/langchain-ai/langgraph/compare/0.4.4...0.4.6)

Updates `litellm` from 1.88.6 to 1.100.4
- [Release notes](https://github.com/BerriAI/litellm/releases)
- [Commits](https://github.com/BerriAI/litellm/compare/v1.88.6...v1.100.4)

---
updated-dependencies:
- dependency-name: nltk
  dependency-version: 3.10.4
  dependency-type: indirect
  dependency-group: uv
- dependency-name: litellm
  dependency-version: 1.100.4
  dependency-type: direct:production
  dependency-group: uv
- dependency-name: oauthlib
  dependency-version: 4.0.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: authlib
  dependency-version: 1.9.1
  dependency-type: indirect
  dependency-group: uv
- dependency-name: fastmcp
  dependency-version: 3.4.10
  dependency-type: indirect
  dependency-group: uv
- dependency-name: joserfc
  dependency-version: 1.7.6
  dependency-type: indirect
  dependency-group: uv
- dependency-name: pyasn1
  dependency-version: 0.6.5
  dependency-type: indirect
  dependency-group: uv
- dependency-name: pyasn1
  dependency-version: 0.6.5
  dependency-type: indirect
  dependency-group: uv
- dependency-name: litellm
  dependency-version: 1.100.4
  dependency-type: direct:production
  dependency-group: uv
- dependency-name: langgraph-sdk
  dependency-version: 0.4.6
  dependency-type: indirect
  dependency-group: uv
- dependency-name: langgraph-sdk
  dependency-version: 0.4.12
  dependency-type: indirect
  dependency-group: uv
- dependency-name: litellm
  dependency-version: 1.100.4
  dependency-type: direct:production
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 examples/example-ai-crewai/pyproject.toml   |   2 +-
 examples/example-ai-crewai/uv.lock          | 105 ++++++++++++++++++--
 examples/example-ai-dspy/pyproject.toml     |   2 +-
 examples/example-ai-dspy/uv.lock            | 101 ++++++++++++++++++-
 examples/example-ai-gemini/uv.lock          |  29 ++++--
 examples/example-ai-langchain/uv.lock       |  41 +++++---
 examples/example-ai-langgraph/uv.lock       |  29 ++++--
 examples/example-ai-litellm/pyproject.toml  |   2 +-
 examples/example-ai-litellm/uv.lock         | 105 +++++++++++++++++++-
 examples/example-ai-llamaindex/uv.lock      |  23 ++++-
 examples/example-ai-pydantic-ai/uv.lock     |  47 +++++----
 examples/example-ai-semantic-kernel/uv.lock |  23 ++++-
 playgrounds/fastapi-async-client/uv.lock    |  23 ++++-
 13 files changed, 448 insertions(+), 84 deletions(-)

diff --git a/examples/example-ai-crewai/pyproject.toml b/examples/example-ai-crewai/pyproject.toml
index 0c6cb57f8..f4872d20a 100644
--- a/examples/example-ai-crewai/pyproject.toml
+++ b/examples/example-ai-crewai/pyproject.toml
@@ -5,5 +5,5 @@ requires-python = ">=3.10"
 dependencies = [
     "posthog==7.9.12",
     "crewai>=0.80.0",
-    "litellm>=1.88.6",
+    "litellm>=1.100.4",
 ]
diff --git a/examples/example-ai-crewai/uv.lock b/examples/example-ai-crewai/uv.lock
index 32a7cf5d2..2078e56c2 100644
--- a/examples/example-ai-crewai/uv.lock
+++ b/examples/example-ai-crewai/uv.lock
@@ -394,6 +394,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" },
 ]
 
+[[package]]
+name = "boto3"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/8a/64b46f075149f9160da44aa7e1052dd18431b9ad4435beb0cfb02cc48624/boto3-1.43.123.tar.gz", hash = "sha256:055fabb990c5d2f31fce4ca569255bd640cdd11a3ca68c9ecad35f4f8a5b83b5", size = 112638, upload-time = "2026-10-30T19:18:50.085Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/b2/a7986c327f80aa6f1544f4cb8f2fa7da4e1fccd472379a21cad0508b8a0e/boto3-1.43.123-py3-none-any.whl", hash = "sha256:d18d66e1e13faa0c25d0b1b8c5ce946e29fb5fc0b6456b655a93a678ff4cc313", size = 140044, upload-time = "2026-10-30T19:18:47.734Z" },
+]
+
+[[package]]
+name = "botocore"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/de/011fc2a47fb066c47064b122498d2fd21f55bc90ea514acbddc37ca0f8c1/botocore-1.43.123.tar.gz", hash = "sha256:80948cb9b1cdf1a1a25809089a42e3a1bc4af0258d198222db6e97dcc660dd0c", size = 16486269, upload-time = "2026-10-30T19:18:44.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/96/4f2dffd304425c07160ab2c12cb13322d852fd956fe9d4386228c93f02ea/botocore-1.43.123-py3-none-any.whl", hash = "sha256:e30580f9c1282c321529238ff8ff75066096a2adbd0a293c8ae592c21d1733a3", size = 16185987, upload-time = "2026-10-30T19:18:39.794Z" },
+]
+
 [[package]]
 name = "build"
 version = "1.4.2"
@@ -629,7 +657,8 @@ dependencies = [
     { name = "overrides" },
     { name = "pybase64" },
     { name = "pydantic" },
-    { name = "pydantic-settings" },
+    { name = "pydantic-settings", version = "2.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pydantic-settings", version = "2.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "pypika" },
     { name = "pyyaml" },
     { name = "rich" },
@@ -839,7 +868,7 @@ dependencies = [
 [package.metadata]
 requires-dist = [
     { name = "crewai", specifier = ">=0.80.0" },
-    { name = "litellm", specifier = ">=1.88.6" },
+    { name = "litellm", specifier = ">=1.100.4" },
     { name = "posthog", specifier = "==7.9.12" },
 ]
 
@@ -1553,6 +1582,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d9/71/71408b02c6133153336d29fa3ba53000f1e1a3f78bb2fc2d1a1865d2e743/jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18c77aaa9117510d5bdc6a946baf21b1f0cfa58ef04d31c8d016f206f2118960", size = 343697, upload-time = "2025-10-17T11:31:13.773Z" },
 ]
 
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
 [[package]]
 name = "json-repair"
 version = "0.60.1"
@@ -1629,10 +1667,11 @@ wheels = [
 
 [[package]]
 name = "litellm"
-version = "1.88.6"
+version = "1.100.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
+    { name = "boto3" },
     { name = "click" },
     { name = "fastuuid" },
     { name = "httpx" },
@@ -1641,13 +1680,21 @@ dependencies = [
     { name = "jsonschema" },
     { name = "openai" },
     { name = "pydantic" },
+    { name = "pydantic-settings", version = "2.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pydantic-settings", version = "2.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "python-dotenv" },
     { name = "tiktoken" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/a6/d2312da4d65390f0d899a669731500983c8a10bd89009657680949c5766d/litellm-1.88.6.tar.gz", hash = "sha256:07d947dfe92f137d5296c40285dbcf97cb405b4300d73c0feda48d76468d6eb4", size = 13889078, upload-time = "2026-08-09T00:06:33.818Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/63/28fb5696e52f40f4bafd096a3d0ed2c8679a24311ed89c200a280ee3b68a/litellm-1.100.4.tar.gz", hash = "sha256:c031cbc63848be16403725594f6060fe002dc2e65f0866878285d72923ac27ab", size = 17338625, upload-time = "2026-09-29T23:04:57.065Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/0b/2e42b95ccca2e2a8a524808e9c414f70a0352165dac589efa01192afb8ba/litellm-1.88.6-py3-none-any.whl", hash = "sha256:8c01f7e9aebded5b3509128be648518a2ec4f1feb8dfb87a539895091651898b", size = 15271205, upload-time = "2026-08-09T00:06:30.607Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5e/407031806577da6b1f3c9217774dabcc1353345337282093915411596aa9/litellm-1.100.4-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c86e2e3370674557547022eb9acd8ec842f802bddb2cfa97992332ad56309a53", size = 23902271, upload-time = "2026-09-29T23:04:39.582Z" },
+    { url = "https://files.pythonhosted.org/packages/db/71/a284cce63fa6c37dab677415d146c968d9d802e1eed2778efcdddba49010/litellm-1.100.4-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:737c99748f9a37e74d4927ad9fe311e3f531a5379ea423eb0d1412d3310f1643", size = 23553194, upload-time = "2026-09-29T23:04:43.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/55/c16164e6cbae93437f50aaf550c5dcacc7a1ca4f1af80ece2c116fbeb01e/litellm-1.100.4-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7228d4d12eb332e5e7b7dbfeb41a4182784ad2acf86f6b7eb806565e04912ada", size = 23696180, upload-time = "2026-09-29T23:04:45.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/09/d99612074d3e114c449fc928d7374f09d8e87cc74dc36fdbb466fc1b9f5a/litellm-1.100.4-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:ded14b15466163c76c9a7da0cd091663b4bebbff9aa56724a5905386a9d12532", size = 24066201, upload-time = "2026-09-29T23:04:48.071Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a0/cc57f435963705f6baeaa717a870a616dd83981217daa81c9de2c2456a0d/litellm-1.100.4-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eb12645456c19dd56f1fa5d7e165a2a76effb1501ace5d0a4df18efc0ac5c39a", size = 23769546, upload-time = "2026-09-29T23:04:50.353Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/dd/b7b458120100e47fa17718fa7aa7f1953cc01b34ce0439cc9f681cc746a0/litellm-1.100.4-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:aa8e8507678451b18c4369b69506d8948154b2ab4af211454dd062380597c1ce", size = 24166511, upload-time = "2026-09-29T23:04:52.583Z" },
+    { url = "https://files.pythonhosted.org/packages/26/35/51d5be49f6add1bea14a0d47cb4f125fc343150095e2e655aa02cba2e885/litellm-1.100.4-cp310-abi3-win_amd64.whl", hash = "sha256:83342175eb948f146f405735b03c1cb1e5c332aeef6a98cfb31f59233d10426a", size = 23981383, upload-time = "2026-09-29T23:04:54.838Z" },
 ]
 
 [[package]]
@@ -2251,11 +2298,11 @@ wheels = [
 
 [[package]]
 name = "oauthlib"
-version = "4.0.0"
+version = "4.0.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7a/d8/a1bcc8ba112a627f8ffbdc212a78ce18d3ac07e91a5ca65d27918eee25a1/oauthlib-4.0.0.tar.gz", hash = "sha256:efb274799819440f95b4ab3b818869f1ce9ae26c5beacba0201d1a1b76b54f86", size = 187232, upload-time = "2026-09-28T06:01:18.77Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/17/2bb072de0b990303c985f26869fd47bb179024a051f47e7f9d208eb92f8e/oauthlib-4.0.1.tar.gz", hash = "sha256:3d73febdb6faa00f277c81fb04be7b7586fb96fc3b7f0b9c772dada69a25ede7", size = 191219, upload-time = "2026-10-31T09:52:58.008Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d9/f4/78229a1066068ca14fc60fb26cf7381cabe4382261392b90e5f9552722d4/oauthlib-4.0.0-py3-none-any.whl", hash = "sha256:624c28c13a0a59cabf9747dfa52af63be3e512a7f2714df16e91b5b3a145e6cd", size = 159715, upload-time = "2026-09-28T06:01:17.008Z" },
+    { url = "https://files.pythonhosted.org/packages/df/ef/3b8adde1b32a6f540758bff734d3442c621734c83708e5f02b0ba2f43b84/oauthlib-4.0.1-py3-none-any.whl", hash = "sha256:498a298876e996301950a5b053d12c31628bb7b895db03666430c69ce182eb61", size = 161934, upload-time = "2026-10-31T09:52:56.206Z" },
 ]
 
 [[package]]
@@ -3187,16 +3234,40 @@ wheels = [
 
 [[package]]
 name = "pydantic-settings"
-version = "2.10.1"
+version = "2.15.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/ca/31c57507b13119d7d3cfa1576dad2911a4861e3be07b579395f4e9d393f9/pydantic_settings-2.15.0.tar.gz", hash = "sha256:694b793e84f766ba76a90ebdefc01d0a9a045dab0382bee70393da93712ad117", size = 261253, upload-time = "2026-08-07T09:24:57.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/30/a4/2bffa9f8e804325a09867f0e9d30795c80ea9f8d62560bd1b6ad6220eb2f/pydantic_settings-2.15.0-py3-none-any.whl", hash = "sha256:0ba092c291c94baceb5eff768aa0d56400a457585bc0175925a5a5510303da42", size = 69413, upload-time = "2026-08-07T09:24:55.839Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.16.2"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.14'",
+    "python_full_version == '3.13.*'",
+    "python_full_version == '3.12.*'",
+    "python_full_version == '3.11.*'",
+]
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
+    { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/31/21d21e0e38a8f5f7a7f0cde22820117b6d17d6bc36f348129527f915d7f4/pydantic_settings-2.16.2.tar.gz", hash = "sha256:3dc08ffabed2bbd5dc2dd55ead7b78b4e4c5cd776aecd04310db5f1224caaf46", size = 309225, upload-time = "2026-10-28T11:14:28.066Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
+    { url = "https://files.pythonhosted.org/packages/39/88/4131c51ff87b7cd7f82a1194d0c0a2b7ca68c72d9da04c3b7e69ab91a79f/pydantic_settings-2.16.2-py3-none-any.whl", hash = "sha256:8d523e5c129b097686bde019bd6109bff53f4c8c3f63f1ddf9933ffa42e5ab4f", size = 81994, upload-time = "2026-10-28T11:14:26.716Z" },
 ]
 
 [[package]]
@@ -3679,6 +3750,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
 ]
 
+[[package]]
+name = "s3transfer"
+version = "0.19.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/c5/0a5ce655109cb96b8dfad36908a4e108d15f5dc2eff8fbc3146c4312e704/s3transfer-0.19.3.tar.gz", hash = "sha256:8326acc3d056d7f7b8a37110c7d2aea41f67e83f6ae79cd3b5fbcca34c726406", size = 166087, upload-time = "2026-10-19T19:19:49.751Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/a4/88f9e10498759121060b8050a1554753dfc04df39bbbcc7aad9ecc8d9440/s3transfer-0.19.3-py3-none-any.whl", hash = "sha256:24eb7535804306355e31c952a90022bf5b2f9d760f9a11062c7493a217c08553", size = 90252, upload-time = "2026-10-19T19:19:48.309Z" },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
diff --git a/examples/example-ai-dspy/pyproject.toml b/examples/example-ai-dspy/pyproject.toml
index a78ea7b6d..47c1ce9fd 100644
--- a/examples/example-ai-dspy/pyproject.toml
+++ b/examples/example-ai-dspy/pyproject.toml
@@ -5,5 +5,5 @@ requires-python = ">=3.10"
 dependencies = [
     "posthog==7.9.12",
     "dspy>=2.5.0",
-    "litellm==1.88.6",
+    "litellm==1.100.4",
 ]
diff --git a/examples/example-ai-dspy/uv.lock b/examples/example-ai-dspy/uv.lock
index c6411e96c..d97600016 100644
--- a/examples/example-ai-dspy/uv.lock
+++ b/examples/example-ai-dspy/uv.lock
@@ -300,6 +300,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148, upload-time = "2022-10-05T19:19:30.546Z" },
 ]
 
+[[package]]
+name = "boto3"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/8a/64b46f075149f9160da44aa7e1052dd18431b9ad4435beb0cfb02cc48624/boto3-1.43.123.tar.gz", hash = "sha256:055fabb990c5d2f31fce4ca569255bd640cdd11a3ca68c9ecad35f4f8a5b83b5", size = 112638, upload-time = "2026-10-30T19:18:50.085Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/b2/a7986c327f80aa6f1544f4cb8f2fa7da4e1fccd472379a21cad0508b8a0e/boto3-1.43.123-py3-none-any.whl", hash = "sha256:d18d66e1e13faa0c25d0b1b8c5ce946e29fb5fc0b6456b655a93a678ff4cc313", size = 140044, upload-time = "2026-10-30T19:18:47.734Z" },
+]
+
+[[package]]
+name = "botocore"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/de/011fc2a47fb066c47064b122498d2fd21f55bc90ea514acbddc37ca0f8c1/botocore-1.43.123.tar.gz", hash = "sha256:80948cb9b1cdf1a1a25809089a42e3a1bc4af0258d198222db6e97dcc660dd0c", size = 16486269, upload-time = "2026-10-30T19:18:44.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/96/4f2dffd304425c07160ab2c12cb13322d852fd956fe9d4386228c93f02ea/botocore-1.43.123-py3-none-any.whl", hash = "sha256:e30580f9c1282c321529238ff8ff75066096a2adbd0a293c8ae592c21d1733a3", size = 16185987, upload-time = "2026-10-30T19:18:39.794Z" },
+]
+
 [[package]]
 name = "cachetools"
 version = "7.0.5"
@@ -526,7 +554,7 @@ dependencies = [
 [package.metadata]
 requires-dist = [
     { name = "dspy", specifier = ">=2.5.0" },
-    { name = "litellm", specifier = "==1.88.6" },
+    { name = "litellm", specifier = "==1.100.4" },
     { name = "posthog", specifier = "==7.9.12" },
 ]
 
@@ -1026,6 +1054,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/67/8a/a342b2f0251f3dac4ca17618265d93bf244a2a4d089126e81e4c1056ac50/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19", size = 343768, upload-time = "2026-02-02T12:37:55.055Z" },
 ]
 
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
 [[package]]
 name = "json-repair"
 version = "0.60.1"
@@ -1064,10 +1101,11 @@ wheels = [
 
 [[package]]
 name = "litellm"
-version = "1.88.6"
+version = "1.100.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
+    { name = "boto3" },
     { name = "click" },
     { name = "fastuuid" },
     { name = "httpx" },
@@ -1076,13 +1114,21 @@ dependencies = [
     { name = "jsonschema" },
     { name = "openai" },
     { name = "pydantic" },
+    { name = "pydantic-settings", version = "2.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pydantic-settings", version = "2.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "python-dotenv" },
     { name = "tiktoken" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/a6/d2312da4d65390f0d899a669731500983c8a10bd89009657680949c5766d/litellm-1.88.6.tar.gz", hash = "sha256:07d947dfe92f137d5296c40285dbcf97cb405b4300d73c0feda48d76468d6eb4", size = 13889078, upload-time = "2026-08-09T00:06:33.818Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/63/28fb5696e52f40f4bafd096a3d0ed2c8679a24311ed89c200a280ee3b68a/litellm-1.100.4.tar.gz", hash = "sha256:c031cbc63848be16403725594f6060fe002dc2e65f0866878285d72923ac27ab", size = 17338625, upload-time = "2026-09-29T23:04:57.065Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/0b/2e42b95ccca2e2a8a524808e9c414f70a0352165dac589efa01192afb8ba/litellm-1.88.6-py3-none-any.whl", hash = "sha256:8c01f7e9aebded5b3509128be648518a2ec4f1feb8dfb87a539895091651898b", size = 15271205, upload-time = "2026-08-09T00:06:30.607Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5e/407031806577da6b1f3c9217774dabcc1353345337282093915411596aa9/litellm-1.100.4-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c86e2e3370674557547022eb9acd8ec842f802bddb2cfa97992332ad56309a53", size = 23902271, upload-time = "2026-09-29T23:04:39.582Z" },
+    { url = "https://files.pythonhosted.org/packages/db/71/a284cce63fa6c37dab677415d146c968d9d802e1eed2778efcdddba49010/litellm-1.100.4-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:737c99748f9a37e74d4927ad9fe311e3f531a5379ea423eb0d1412d3310f1643", size = 23553194, upload-time = "2026-09-29T23:04:43.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/55/c16164e6cbae93437f50aaf550c5dcacc7a1ca4f1af80ece2c116fbeb01e/litellm-1.100.4-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7228d4d12eb332e5e7b7dbfeb41a4182784ad2acf86f6b7eb806565e04912ada", size = 23696180, upload-time = "2026-09-29T23:04:45.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/09/d99612074d3e114c449fc928d7374f09d8e87cc74dc36fdbb466fc1b9f5a/litellm-1.100.4-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:ded14b15466163c76c9a7da0cd091663b4bebbff9aa56724a5905386a9d12532", size = 24066201, upload-time = "2026-09-29T23:04:48.071Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a0/cc57f435963705f6baeaa717a870a616dd83981217daa81c9de2c2456a0d/litellm-1.100.4-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eb12645456c19dd56f1fa5d7e165a2a76effb1501ace5d0a4df18efc0ac5c39a", size = 23769546, upload-time = "2026-09-29T23:04:50.353Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/dd/b7b458120100e47fa17718fa7aa7f1953cc01b34ce0439cc9f681cc746a0/litellm-1.100.4-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:aa8e8507678451b18c4369b69506d8948154b2ab4af211454dd062380597c1ce", size = 24166511, upload-time = "2026-09-29T23:04:52.583Z" },
+    { url = "https://files.pythonhosted.org/packages/26/35/51d5be49f6add1bea14a0d47cb4f125fc343150095e2e655aa02cba2e885/litellm-1.100.4-cp310-abi3-win_amd64.whl", hash = "sha256:83342175eb948f146f405735b03c1cb1e5c332aeef6a98cfb31f59233d10426a", size = 23981383, upload-time = "2026-09-29T23:04:54.838Z" },
 ]
 
 [[package]]
@@ -1923,6 +1969,41 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
 ]
 
+[[package]]
+name = "pydantic-settings"
+version = "2.15.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/ca/31c57507b13119d7d3cfa1576dad2911a4861e3be07b579395f4e9d393f9/pydantic_settings-2.15.0.tar.gz", hash = "sha256:694b793e84f766ba76a90ebdefc01d0a9a045dab0382bee70393da93712ad117", size = 261253, upload-time = "2026-08-07T09:24:57.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/30/a4/2bffa9f8e804325a09867f0e9d30795c80ea9f8d62560bd1b6ad6220eb2f/pydantic_settings-2.15.0-py3-none-any.whl", hash = "sha256:0ba092c291c94baceb5eff768aa0d56400a457585bc0175925a5a5510303da42", size = 69413, upload-time = "2026-08-07T09:24:55.839Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.16.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.11'",
+]
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/31/21d21e0e38a8f5f7a7f0cde22820117b6d17d6bc36f348129527f915d7f4/pydantic_settings-2.16.2.tar.gz", hash = "sha256:3dc08ffabed2bbd5dc2dd55ead7b78b4e4c5cd776aecd04310db5f1224caaf46", size = 309225, upload-time = "2026-10-28T11:14:28.066Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/88/4131c51ff87b7cd7f82a1194d0c0a2b7ca68c72d9da04c3b7e69ab91a79f/pydantic_settings-2.16.2-py3-none-any.whl", hash = "sha256:8d523e5c129b097686bde019bd6109bff53f4c8c3f63f1ddf9933ffa42e5ab4f", size = 81994, upload-time = "2026-10-28T11:14:26.716Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.20.0"
@@ -2302,6 +2383,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
 ]
 
+[[package]]
+name = "s3transfer"
+version = "0.19.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/c5/0a5ce655109cb96b8dfad36908a4e108d15f5dc2eff8fbc3146c4312e704/s3transfer-0.19.3.tar.gz", hash = "sha256:8326acc3d056d7f7b8a37110c7d2aea41f67e83f6ae79cd3b5fbcca34c726406", size = 166087, upload-time = "2026-10-19T19:19:49.751Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/a4/88f9e10498759121060b8050a1554753dfc04df39bbbcc7aad9ecc8d9440/s3transfer-0.19.3-py3-none-any.whl", hash = "sha256:24eb7535804306355e31c952a90022bf5b2f9d760f9a11062c7493a217c08553", size = 90252, upload-time = "2026-10-19T19:19:48.309Z" },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
diff --git a/examples/example-ai-gemini/uv.lock b/examples/example-ai-gemini/uv.lock
index 0402b9905..e90030424 100644
--- a/examples/example-ai-gemini/uv.lock
+++ b/examples/example-ai-gemini/uv.lock
@@ -43,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -597,7 +597,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -645,9 +645,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -675,7 +688,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
@@ -697,11 +710,11 @@ wheels = [
 
 [[package]]
 name = "pyasn1"
-version = "0.6.4"
+version = "0.6.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a4/9a/23310166d960def5897e91fe20e5b724601b02a22e84ba1f94232c0b7f67/pyasn1-0.6.4.tar.gz", hash = "sha256:9c447d8431c947fe4c8febc4ed9e760bc29011a5b01e5c74b67025bd9fb8ce81", size = 151262, upload-time = "2026-07-09T01:12:33.988Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/88/7e/3c0da41061a2021cac7cd524fd57092adbe5b515e8bf9005702e366802e2/pyasn1-0.6.5.tar.gz", hash = "sha256:6b11616a6bcf3a40e635f082bb232fa57b5e0dd7f517bd7ddd69ec3794508a47", size = 155152, upload-time = "2026-10-27T06:32:49.125Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3b/6163796d69c3977d1e4287bea4a6979161cbbdd170ebb430511e8e1999ce/pyasn1-0.6.4-py3-none-any.whl", hash = "sha256:deda9277cfd454080ec40b207fb6df82206a3a2688735233cdcd8d3d565f088b", size = 84410, upload-time = "2026-07-09T01:12:32.92Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1f/3eefd5c84c35cae44549ce1c7f7e58f7945b34f5a6bce07a135438522073/pyasn1-0.6.5-py3-none-any.whl", hash = "sha256:4017b0fce125096b8573b39c989fdb1a4b19cf761e683398184550fea0e66587", size = 84807, upload-time = "2026-10-27T06:32:48.045Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-langchain/uv.lock b/examples/example-ai-langchain/uv.lock
index 00c05f8ec..a6c8d1a9d 100644
--- a/examples/example-ai-langchain/uv.lock
+++ b/examples/example-ai-langchain/uv.lock
@@ -43,11 +43,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -444,7 +444,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.9"
+version = "1.2.19"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
@@ -454,22 +454,22 @@ dependencies = [
     { name = "pydantic" },
     { name = "xxhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/41/4b/0d1130e26b41a99dcc88353bbe7162a1f255c4db746bd94024268e6af27b/langgraph-1.2.9.tar.gz", hash = "sha256:385f87bc1802c35af7e0aa479278ecba8582d103515eb48256cb2ddcd42d0bd4", size = 722869, upload-time = "2026-07-10T01:30:14.985Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/10/329dc49ce3fc40e36faafd407f08607fe3fab75613e709a66758b53faac2/langgraph-1.2.19.tar.gz", hash = "sha256:4a00fa1aad2b5fc2d3a789a8e9eaf993f76218ca924b434902ecf1bbaaf300f6", size = 782618, upload-time = "2026-10-30T22:23:32.962Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/16/0b8dc48823f1326f3e0c8012a3c07a40da6f194299e2ec080df236287baf/langgraph-1.2.9-py3-none-any.whl", hash = "sha256:c2d98ad94333937922ba04148641c1da2bfe45b5b8e55d7b6dcb0bb2df809e76", size = 247473, upload-time = "2026-07-10T01:30:13.733Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/9e/bd29e368fb16feea8d24270d377d56c34b49afea371717124f19cdfa890c/langgraph-1.2.19-py3-none-any.whl", hash = "sha256:6094a5cbed52a77d8c74c276fcd2056abde7b2836eab1c7a6b74bacbd1a269b3", size = 262285, upload-time = "2026-10-30T22:23:31.334Z" },
 ]
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.1.1"
+version = "4.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "ormsgpack" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/83/47/886af6f886f0bff2273164a45f008694e48a96ff3cd25ff0228f2aa9480e/langgraph_checkpoint-4.1.1.tar.gz", hash = "sha256:6c2bdb530c91f91d7d9c1bd100925d0fc4f498d418c17f3587d1526279482a25", size = 184020, upload-time = "2026-05-22T16:57:38.503Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/c4/f4107f50dd07169d08d95766cd69104231e694f44a1b25b68ad8b393712d/langgraph_checkpoint-4.3.1.tar.gz", hash = "sha256:625e7c78a72b33e7c47f7e87ca051060fb90aa66f5fd551c472c08376fb669cb", size = 182679, upload-time = "2026-10-26T19:57:31.416Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bd/b4/71425e3e38be92611300b9cc5e46a5bf98ab23f5ea8a75b73d02a2f1413c/langgraph_checkpoint-4.1.1-py3-none-any.whl", hash = "sha256:25d29144b082827218e7bc3f1e9b0566a4bb007895cd6cc26f66a8428739f56e", size = 56212, upload-time = "2026-05-22T16:57:37.203Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/40/4251d676b5c585d42175c901175d4bff56e22939625e18bcef781fc3e893/langgraph_checkpoint-4.3.1-py3-none-any.whl", hash = "sha256:215a826935c8db4d9676e79fd95943e5b3847d78604390898e1d98581cc594e5", size = 58093, upload-time = "2026-10-26T19:57:30.361Z" },
 ]
 
 [[package]]
@@ -487,7 +487,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.4.4"
+version = "0.4.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -496,9 +496,9 @@ dependencies = [
     { name = "orjson" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3f/ae/91446c1fffa04a2dc1f81afbfb5bfff3590452891a72bd9098a656ab2657/langgraph_sdk-0.4.4.tar.gz", hash = "sha256:4e651ffa09de695681579396375377bdde23bedbc8e35b070e615cbd5af7da8b", size = 345789, upload-time = "2026-08-27T21:25:22.593Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/44/3b07ae42ebfd3cc343201a2ff708d470867082810e747ea5d8dd85de50ec/langgraph_sdk-0.4.12.tar.gz", hash = "sha256:2f7ea2b9a7048e1ff9c3be7308b36eb56d6bfcccbe8100aeea6db688002219e0", size = 369804, upload-time = "2026-11-03T18:10:16.606Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/d5/2ad7f3a835c6fcebf58b6669552536ecd52d2dfe4cf49c6c36648fd83572/langgraph_sdk-0.4.4-py3-none-any.whl", hash = "sha256:39afe416c91742925e6f8a93715f566d499b36e1b636b804a4ffe3190e4f4e64", size = 162270, upload-time = "2026-08-27T21:25:21.072Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/7c/3789d5bfa872f87ed8443177baf5fe51da5840ccbabdbe87dac3fc65e9bd/langgraph_sdk-0.4.12-py3-none-any.whl", hash = "sha256:cfc2e659a3daa615062a29cfa39eea00b5ea58d2683dbf2f4487fc4244a98078", size = 170444, upload-time = "2026-11-03T18:10:15.309Z" },
 ]
 
 [[package]]
@@ -848,7 +848,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -896,9 +896,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -926,7 +939,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
diff --git a/examples/example-ai-langgraph/uv.lock b/examples/example-ai-langgraph/uv.lock
index 436b5d46a..11180b80f 100644
--- a/examples/example-ai-langgraph/uv.lock
+++ b/examples/example-ai-langgraph/uv.lock
@@ -47,11 +47,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -477,7 +477,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.4.4"
+version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -486,9 +486,9 @@ dependencies = [
     { name = "orjson" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3f/ae/91446c1fffa04a2dc1f81afbfb5bfff3590452891a72bd9098a656ab2657/langgraph_sdk-0.4.4.tar.gz", hash = "sha256:4e651ffa09de695681579396375377bdde23bedbc8e35b070e615cbd5af7da8b", size = 345789, upload-time = "2026-08-27T21:25:22.593Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/85/54edf4902c0378510f09a009f64e3d3f5644aeeb51d13cf67ec380a5245b/langgraph_sdk-0.4.6.tar.gz", hash = "sha256:ea5b1749d70987d741c9b9fe2b7e1c5f7da7e4d102f64e390333c1890c9bbd5b", size = 350632, upload-time = "2026-10-06T14:17:53.641Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/d5/2ad7f3a835c6fcebf58b6669552536ecd52d2dfe4cf49c6c36648fd83572/langgraph_sdk-0.4.4-py3-none-any.whl", hash = "sha256:39afe416c91742925e6f8a93715f566d499b36e1b636b804a4ffe3190e4f4e64", size = 162270, upload-time = "2026-08-27T21:25:21.072Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/c7/69d13026db3577c157877dea47a9dc5fffd3dcde2d1ab8009fa8f7e5f6a6/langgraph_sdk-0.4.6-py3-none-any.whl", hash = "sha256:57122b02bda41d37a97a5e09eb018aa8c9b3dc85c433880073779bd9324b7eea", size = 162390, upload-time = "2026-10-06T14:17:52.134Z" },
 ]
 
 [[package]]
@@ -834,7 +834,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -882,9 +882,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -912,7 +925,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
diff --git a/examples/example-ai-litellm/pyproject.toml b/examples/example-ai-litellm/pyproject.toml
index 0691dbfb5..5efd3520a 100644
--- a/examples/example-ai-litellm/pyproject.toml
+++ b/examples/example-ai-litellm/pyproject.toml
@@ -4,5 +4,5 @@ version = "0.1.0"
 requires-python = ">=3.10"
 dependencies = [
     "posthog==7.9.12",
-    "litellm==1.88.6",
+    "litellm==1.100.4",
 ]
diff --git a/examples/example-ai-litellm/uv.lock b/examples/example-ai-litellm/uv.lock
index 00bfa8a21..e8f2a90d6 100644
--- a/examples/example-ai-litellm/uv.lock
+++ b/examples/example-ai-litellm/uv.lock
@@ -1,6 +1,10 @@
 version = 1
 revision = 5
 requires-python = ">=3.10"
+resolution-markers = [
+    "python_full_version >= '3.11'",
+    "python_full_version < '3.11'",
+]
 
 [options]
 exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
@@ -269,6 +273,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148, upload-time = "2022-10-05T19:19:30.546Z" },
 ]
 
+[[package]]
+name = "boto3"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+    { name = "jmespath" },
+    { name = "s3transfer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/8a/64b46f075149f9160da44aa7e1052dd18431b9ad4435beb0cfb02cc48624/boto3-1.43.123.tar.gz", hash = "sha256:055fabb990c5d2f31fce4ca569255bd640cdd11a3ca68c9ecad35f4f8a5b83b5", size = 112638, upload-time = "2026-10-30T19:18:50.085Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/b2/a7986c327f80aa6f1544f4cb8f2fa7da4e1fccd472379a21cad0508b8a0e/boto3-1.43.123-py3-none-any.whl", hash = "sha256:d18d66e1e13faa0c25d0b1b8c5ce946e29fb5fc0b6456b655a93a678ff4cc313", size = 140044, upload-time = "2026-10-30T19:18:47.734Z" },
+]
+
+[[package]]
+name = "botocore"
+version = "1.43.123"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jmespath" },
+    { name = "python-dateutil" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e0/de/011fc2a47fb066c47064b122498d2fd21f55bc90ea514acbddc37ca0f8c1/botocore-1.43.123.tar.gz", hash = "sha256:80948cb9b1cdf1a1a25809089a42e3a1bc4af0258d198222db6e97dcc660dd0c", size = 16486269, upload-time = "2026-10-30T19:18:44.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/96/4f2dffd304425c07160ab2c12cb13322d852fd956fe9d4386228c93f02ea/botocore-1.43.123-py3-none-any.whl", hash = "sha256:e30580f9c1282c321529238ff8ff75066096a2adbd0a293c8ae592c21d1733a3", size = 16185987, upload-time = "2026-10-30T19:18:39.794Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2026.10.23"
@@ -424,7 +456,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "litellm", specifier = "==1.88.6" },
+    { name = "litellm", specifier = "==1.100.4" },
     { name = "posthog", specifier = "==7.9.12" },
 ]
 
@@ -861,6 +893,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/67/8a/a342b2f0251f3dac4ca17618265d93bf244a2a4d089126e81e4c1056ac50/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19", size = 343768, upload-time = "2026-02-02T12:37:55.055Z" },
 ]
 
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
 [[package]]
 name = "jsonschema"
 version = "4.23.0"
@@ -890,10 +931,11 @@ wheels = [
 
 [[package]]
 name = "litellm"
-version = "1.88.6"
+version = "1.100.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
+    { name = "boto3" },
     { name = "click" },
     { name = "fastuuid" },
     { name = "httpx" },
@@ -902,13 +944,21 @@ dependencies = [
     { name = "jsonschema" },
     { name = "openai" },
     { name = "pydantic" },
+    { name = "pydantic-settings", version = "2.15.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "pydantic-settings", version = "2.16.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "python-dotenv" },
     { name = "tiktoken" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/a6/d2312da4d65390f0d899a669731500983c8a10bd89009657680949c5766d/litellm-1.88.6.tar.gz", hash = "sha256:07d947dfe92f137d5296c40285dbcf97cb405b4300d73c0feda48d76468d6eb4", size = 13889078, upload-time = "2026-08-09T00:06:33.818Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/63/28fb5696e52f40f4bafd096a3d0ed2c8679a24311ed89c200a280ee3b68a/litellm-1.100.4.tar.gz", hash = "sha256:c031cbc63848be16403725594f6060fe002dc2e65f0866878285d72923ac27ab", size = 17338625, upload-time = "2026-09-29T23:04:57.065Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/0b/2e42b95ccca2e2a8a524808e9c414f70a0352165dac589efa01192afb8ba/litellm-1.88.6-py3-none-any.whl", hash = "sha256:8c01f7e9aebded5b3509128be648518a2ec4f1feb8dfb87a539895091651898b", size = 15271205, upload-time = "2026-08-09T00:06:30.607Z" },
+    { url = "https://files.pythonhosted.org/packages/67/5e/407031806577da6b1f3c9217774dabcc1353345337282093915411596aa9/litellm-1.100.4-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c86e2e3370674557547022eb9acd8ec842f802bddb2cfa97992332ad56309a53", size = 23902271, upload-time = "2026-09-29T23:04:39.582Z" },
+    { url = "https://files.pythonhosted.org/packages/db/71/a284cce63fa6c37dab677415d146c968d9d802e1eed2778efcdddba49010/litellm-1.100.4-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:737c99748f9a37e74d4927ad9fe311e3f531a5379ea423eb0d1412d3310f1643", size = 23553194, upload-time = "2026-09-29T23:04:43.133Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/55/c16164e6cbae93437f50aaf550c5dcacc7a1ca4f1af80ece2c116fbeb01e/litellm-1.100.4-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7228d4d12eb332e5e7b7dbfeb41a4182784ad2acf86f6b7eb806565e04912ada", size = 23696180, upload-time = "2026-09-29T23:04:45.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/09/d99612074d3e114c449fc928d7374f09d8e87cc74dc36fdbb466fc1b9f5a/litellm-1.100.4-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:ded14b15466163c76c9a7da0cd091663b4bebbff9aa56724a5905386a9d12532", size = 24066201, upload-time = "2026-09-29T23:04:48.071Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a0/cc57f435963705f6baeaa717a870a616dd83981217daa81c9de2c2456a0d/litellm-1.100.4-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eb12645456c19dd56f1fa5d7e165a2a76effb1501ace5d0a4df18efc0ac5c39a", size = 23769546, upload-time = "2026-09-29T23:04:50.353Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/dd/b7b458120100e47fa17718fa7aa7f1953cc01b34ce0439cc9f681cc746a0/litellm-1.100.4-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:aa8e8507678451b18c4369b69506d8948154b2ab4af211454dd062380597c1ce", size = 24166511, upload-time = "2026-09-29T23:04:52.583Z" },
+    { url = "https://files.pythonhosted.org/packages/26/35/51d5be49f6add1bea14a0d47cb4f125fc343150095e2e655aa02cba2e885/litellm-1.100.4-cp310-abi3-win_amd64.whl", hash = "sha256:83342175eb948f146f405735b03c1cb1e5c332aeef6a98cfb31f59233d10426a", size = 23981383, upload-time = "2026-09-29T23:04:54.838Z" },
 ]
 
 [[package]]
@@ -1490,6 +1540,41 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
 ]
 
+[[package]]
+name = "pydantic-settings"
+version = "2.15.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/ca/31c57507b13119d7d3cfa1576dad2911a4861e3be07b579395f4e9d393f9/pydantic_settings-2.15.0.tar.gz", hash = "sha256:694b793e84f766ba76a90ebdefc01d0a9a045dab0382bee70393da93712ad117", size = 261253, upload-time = "2026-08-07T09:24:57.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/30/a4/2bffa9f8e804325a09867f0e9d30795c80ea9f8d62560bd1b6ad6220eb2f/pydantic_settings-2.15.0-py3-none-any.whl", hash = "sha256:0ba092c291c94baceb5eff768aa0d56400a457585bc0175925a5a5510303da42", size = 69413, upload-time = "2026-08-07T09:24:55.839Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.16.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.11'",
+]
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/31/21d21e0e38a8f5f7a7f0cde22820117b6d17d6bc36f348129527f915d7f4/pydantic_settings-2.16.2.tar.gz", hash = "sha256:3dc08ffabed2bbd5dc2dd55ead7b78b4e4c5cd776aecd04310db5f1224caaf46", size = 309225, upload-time = "2026-10-28T11:14:28.066Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/88/4131c51ff87b7cd7f82a1194d0c0a2b7ca68c72d9da04c3b7e69ab91a79f/pydantic_settings-2.16.2-py3-none-any.whl", hash = "sha256:8d523e5c129b097686bde019bd6109bff53f4c8c3f63f1ddf9933ffa42e5ab4f", size = 81994, upload-time = "2026-10-28T11:14:26.716Z" },
+]
+
 [[package]]
 name = "pygments"
 version = "2.20.0"
@@ -1869,6 +1954,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
 ]
 
+[[package]]
+name = "s3transfer"
+version = "0.19.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "botocore" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/c5/0a5ce655109cb96b8dfad36908a4e108d15f5dc2eff8fbc3146c4312e704/s3transfer-0.19.3.tar.gz", hash = "sha256:8326acc3d056d7f7b8a37110c7d2aea41f67e83f6ae79cd3b5fbcca34c726406", size = 166087, upload-time = "2026-10-19T19:19:49.751Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/a4/88f9e10498759121060b8050a1554753dfc04df39bbbcc7aad9ecc8d9440/s3transfer-0.19.3-py3-none-any.whl", hash = "sha256:24eb7535804306355e31c952a90022bf5b2f9d760f9a11062c7493a217c08553", size = 90252, upload-time = "2026-10-19T19:19:48.309Z" },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
diff --git a/examples/example-ai-llamaindex/uv.lock b/examples/example-ai-llamaindex/uv.lock
index 25decdb56..224e5a424 100644
--- a/examples/example-ai-llamaindex/uv.lock
+++ b/examples/example-ai-llamaindex/uv.lock
@@ -1376,7 +1376,7 @@ wheels = [
 
 [[package]]
 name = "nltk"
-version = "3.10.3"
+version = "3.10.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -1385,9 +1385,9 @@ dependencies = [
     { name = "regex" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e0/e6/fe51d2bb1a3b446f59c5c8165999a9fee208bc346af90a7cbf7657bc0d75/nltk-3.10.3.tar.gz", hash = "sha256:bb9327a461c3811c2fa4900e03840401f2126adfb30c0072827c433bd2444ea4", size = 5137152, upload-time = "2026-08-12T23:46:37.258Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/cb/bbaa9be58e95d21729c6b9194376610230e0755f6de0bf38b6acc0dce079/nltk-3.10.4.tar.gz", hash = "sha256:44679f4e9220abfd496d2c8cdb22f8425ccbe557604f9aa5cacb1c44003dabc1", size = 4300570, upload-time = "2026-10-21T11:34:35.851Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/6d/ebd2af4640b12168fdf0cb74b6118df2f32a2f62ec7e0c06fbfd80706639/nltk-3.10.3-py3-none-any.whl", hash = "sha256:ff9598a8e20518ee0d557745890cc4435b9578489e2dcbc69c4f81fa060caf7c", size = 1798643, upload-time = "2026-08-12T23:44:13.478Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/04/e7816813e409ca874ba2fcc35455db0e4130b79eb277e1f9edd270ca3c69/nltk-3.10.4-py3-none-any.whl", hash = "sha256:769ba5413f265b7d3e87cd163cc28efa01e29eeef8bb6080bc907949d9fcfb51", size = 1722994, upload-time = "2026-10-21T11:34:27.975Z" },
 ]
 
 [[package]]
@@ -1826,7 +1826,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.76.0"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -1874,9 +1874,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -1904,7 +1917,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
diff --git a/examples/example-ai-pydantic-ai/uv.lock b/examples/example-ai-pydantic-ai/uv.lock
index 6e0b9ef75..bd65c6af3 100644
--- a/examples/example-ai-pydantic-ai/uv.lock
+++ b/examples/example-ai-pydantic-ai/uv.lock
@@ -321,15 +321,15 @@ wheels = [
 
 [[package]]
 name = "authlib"
-version = "1.7.2"
+version = "1.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
     { name = "joserfc" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/36/98/7d93f30d029643c0275dbc0bd6d5a6f670661ee6c9a94d93af7ab4887600/authlib-1.7.2.tar.gz", hash = "sha256:2cea25fefcd4e7173bdf1372c0afc265c8034b23a8cd5dcb6a9164b826c64231", size = 176511, upload-time = "2026-05-06T08:10:23.116Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/dc/087c08741a98d234c9b98beef8a28d3c309f814d14b6156422c5815bf6d6/authlib-1.9.1.tar.gz", hash = "sha256:5c7d9848f47cac340f060f76ae0bc09b59f5c8e89cc1bb032d4370a0c55b5974", size = 182700, upload-time = "2026-10-14T14:17:52.307Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/95/adcb68e20c34162e9135f370d6e31737719c2b6f94bc953fe7ed1f10fe21/authlib-1.7.2-py2.py3-none-any.whl", hash = "sha256:3e1faedc9d87e7d56a164eca3ccb6ace0d61b94abe83e92242f8dc8bba9b4a9f", size = 259548, upload-time = "2026-05-06T08:10:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/39/44/a46089266de32a0d809023b6bf31b80a1f26a46954446a7ce695a565cbea/authlib-1.9.1-py2.py3-none-any.whl", hash = "sha256:8b9be8b1e5174dcbf5520e984f1a22dc2edae5b6e40a61d4cedbf86b97e9e69b", size = 266042, upload-time = "2026-10-14T14:17:50.695Z" },
 ]
 
 [[package]]
@@ -880,19 +880,19 @@ wheels = [
 
 [[package]]
 name = "fastmcp"
-version = "3.4.2"
+version = "3.4.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "fastmcp-slim", extra = ["client", "server"] },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/29/18/46beaec18c9f86a599ae3f9cdf6677dd6b50240cfd844d18233710b47f13/fastmcp-3.4.2.tar.gz", hash = "sha256:b468722946fc467c3796a6572f7a14d93d48c014cf8fea12910245220cbbe4e1", size = 28756849, upload-time = "2026-06-06T01:30:35.694Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/ce/b2057fd2d3e453048ffae962c746ef7bcb9cf6700086fb1dfcff8a8ba65d/fastmcp-3.4.10.tar.gz", hash = "sha256:c6474855d6230cce4feb7084d654ba518578b25856c6ef26a2ff2d806ef68969", size = 28866789, upload-time = "2026-10-20T14:49:39.101Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/4d/8b1ba42251160e11ca34686344572121432c23a082d56ef6bbdec5888fc1/fastmcp-3.4.2-py3-none-any.whl", hash = "sha256:c87a62b029f0c5400ada85f683629345d2466c39169f0cb853e487b2f7308c08", size = 8018, upload-time = "2026-06-06T01:30:38.118Z" },
+    { url = "https://files.pythonhosted.org/packages/40/c4/72da20dfbfce1c99e3c70bc973e736744daf6d461de138f52f9aaa558959/fastmcp-3.4.10-py3-none-any.whl", hash = "sha256:68f422db0a7c6228142663f17d9f79a5a12a509e1408a8ac207b3e442e166e38", size = 8026, upload-time = "2026-10-20T14:49:37.137Z" },
 ]
 
 [[package]]
 name = "fastmcp-slim"
-version = "3.4.2"
+version = "3.4.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "platformdirs" },
@@ -902,9 +902,9 @@ dependencies = [
     { name = "rich" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a3/2e/d627b28b7403ecc526991ef732921b08bde010006e6148635f053fd29f4c/fastmcp_slim-3.4.2.tar.gz", hash = "sha256:290646e0955a516235a317151034559aa48336cb843d3f006131aedad8759bb4", size = 576291, upload-time = "2026-06-06T01:30:12.553Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/3b/28be7f0963fee1c848e78898d801e1232dd2e05b6e37026c400a788caa9a/fastmcp_slim-3.4.10.tar.gz", hash = "sha256:d80ae606ead8dfefa1f21b009929824210ea87eb4b422653a1be8dca61797ccd", size = 610326, upload-time = "2026-10-20T14:49:15.096Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/58/22afebf18df7260b09148199cbeb90cdcc4b3a4e1b5d7460e3591c3a7add/fastmcp_slim-3.4.2-py3-none-any.whl", hash = "sha256:bdc72492212681ca502755fa8acc0457f559295da1fc3dfc0599adc1c04b82f3", size = 749195, upload-time = "2026-06-06T01:30:11.22Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/28/1e0681b524191ee170f40e8e800fd3785084e12806fc46675c70d7f8fa43/fastmcp_slim-3.4.10-py3-none-any.whl", hash = "sha256:f388941db8bdf38999e6c9d2536c4cd59a6571908d851cee2d10ee59f4e53532", size = 785895, upload-time = "2026-10-20T14:49:13.466Z" },
 ]
 
 [package.optional-dependencies]
@@ -1542,14 +1542,14 @@ wheels = [
 
 [[package]]
 name = "joserfc"
-version = "1.7.1"
+version = "1.7.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/44/90/25cb27518750218e4f850be63d8bbb2343efaad1c01c3571aaa4b3c33bd7/joserfc-1.7.1.tar.gz", hash = "sha256:77d0b76514879c68c6f433bc5b7357a4ab72008ff1e33d8379fd11d72bd8ca81", size = 233181, upload-time = "2026-06-08T07:21:33.412Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/db/ec5b5fe07a7bda62cd2c2d619daf160eb7442b979c7cd61bbe0262108de9/joserfc-1.7.6.tar.gz", hash = "sha256:fb1cf6d2977318bef976c2ed2ef2167cc5f8ade8fc96f034e38f7abd656907c4", size = 236091, upload-time = "2026-10-18T23:12:18.43Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/00/fa62404c3e347f946faa13aa21085205f9cc06ad17671e37f81a51662ae8/joserfc-1.7.1-py3-none-any.whl", hash = "sha256:b3e3d655612e2e1ef67b2600f2f420e12e537b020208fab1761fad647319c164", size = 70423, upload-time = "2026-06-08T07:21:32.001Z" },
+    { url = "https://files.pythonhosted.org/packages/98/40/63886ba742c6fd9e6dd222e20b8d54012fbc933465350c7747c4ed5b31e4/joserfc-1.7.6-py3-none-any.whl", hash = "sha256:e2d72e3fa937ed8ddd42ad8c1cc337a43e7ffd02efa572a2aa15e2764a05b506", size = 71588, upload-time = "2026-10-18T23:12:17.085Z" },
 ]
 
 [[package]]
@@ -2111,7 +2111,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.76.0"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2159,9 +2159,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -2189,7 +2202,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
@@ -2362,11 +2375,11 @@ memory = [
 
 [[package]]
 name = "pyasn1"
-version = "0.6.4"
+version = "0.6.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a4/9a/23310166d960def5897e91fe20e5b724601b02a22e84ba1f94232c0b7f67/pyasn1-0.6.4.tar.gz", hash = "sha256:9c447d8431c947fe4c8febc4ed9e760bc29011a5b01e5c74b67025bd9fb8ce81", size = 151262, upload-time = "2026-07-09T01:12:33.988Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/88/7e/3c0da41061a2021cac7cd524fd57092adbe5b515e8bf9005702e366802e2/pyasn1-0.6.5.tar.gz", hash = "sha256:6b11616a6bcf3a40e635f082bb232fa57b5e0dd7f517bd7ddd69ec3794508a47", size = 155152, upload-time = "2026-10-27T06:32:49.125Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/3b/6163796d69c3977d1e4287bea4a6979161cbbdd170ebb430511e8e1999ce/pyasn1-0.6.4-py3-none-any.whl", hash = "sha256:deda9277cfd454080ec40b207fb6df82206a3a2688735233cdcd8d3d565f088b", size = 84410, upload-time = "2026-07-09T01:12:32.92Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1f/3eefd5c84c35cae44549ce1c7f7e58f7945b34f5a6bce07a135438522073/pyasn1-0.6.5-py3-none-any.whl", hash = "sha256:4017b0fce125096b8573b39c989fdb1a4b19cf761e683398184550fea0e66587", size = 84807, upload-time = "2026-10-27T06:32:48.045Z" },
 ]
 
 [[package]]
diff --git a/examples/example-ai-semantic-kernel/uv.lock b/examples/example-ai-semantic-kernel/uv.lock
index b19ee0951..bed187c0a 100644
--- a/examples/example-ai-semantic-kernel/uv.lock
+++ b/examples/example-ai-semantic-kernel/uv.lock
@@ -432,11 +432,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -2032,7 +2032,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.11"
+version = "7.86.6"
 source = { directory = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -2080,9 +2080,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -2110,7 +2123,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]
diff --git a/playgrounds/fastapi-async-client/uv.lock b/playgrounds/fastapi-async-client/uv.lock
index 3548a8c74..cd4842634 100644
--- a/playgrounds/fastapi-async-client/uv.lock
+++ b/playgrounds/fastapi-async-client/uv.lock
@@ -56,11 +56,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.10.19"
+version = "2026.10.23"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a6/bd/1436c50cc46699de0230fbaacc1d1de7bfec413176099949e9d5112e88f2/certifi-2026.10.19.tar.gz", hash = "sha256:035c1e85572b141bf1c3a3eff0e33a8eb74917522f2559075ff8d2fea780a1ae", size = 137598, upload-time = "2026-10-20T02:24:16.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/51/29046e48f693c54e5b7412216d447a1d8362c9653148d98c02cdf65fa733/certifi-2026.10.19-py3-none-any.whl", hash = "sha256:42d35340cc5b9ba78e818ddbff0c5b1c2b779de448a340fd1b989f5fa8670e1b", size = 136464, upload-time = "2026-10-20T02:24:15.072Z" },
+    { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" },
 ]
 
 [[package]]
@@ -399,7 +399,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.75.4"
+version = "7.86.6"
 source = { editable = "../../" }
 dependencies = [
     { name = "backoff" },
@@ -446,9 +446,22 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'" },
     { name = "mypy-baseline", marker = "extra == 'dev'" },
     { name = "openai-agents", marker = "extra == 'test'", specifier = ">=0.18" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'test'", specifier = ">=1.20.0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-aiohttp-client", marker = "extra == 'test'", specifier = ">=0.60b0" },
     { name = "opentelemetry-instrumentation-celery", marker = "extra == 'test'", specifier = ">=0.41b0" },
+    { name = "opentelemetry-instrumentation-django", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-flask", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-httpx", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-requests", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-sqlite3", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'metrics'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-system-metrics", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-instrumentation-wsgi", marker = "extra == 'test'", specifier = ">=0.60b0" },
+    { name = "opentelemetry-sdk", marker = "extra == 'metrics'", specifier = ">=1.39.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'otel'", specifier = ">=1.20.0" },
     { name = "opentelemetry-sdk", marker = "extra == 'test'", specifier = ">=1.20.0" },
     { name = "packaging", marker = "extra == 'dev'" },
@@ -476,7 +489,7 @@ requires-dist = [
     { name = "zstandard", marker = "extra == 'test'", specifier = ">=0.23.0" },
     { name = "zstandard", marker = "extra == 'zstd'", specifier = ">=0.23.0" },
 ]
-provides-extras = ["langchain", "async", "zstd", "otel", "dev", "test"]
+provides-extras = ["langchain", "async", "zstd", "otel", "metrics", "dev", "test"]
 
 [package.metadata.requires-dev]
 dev = [{ name = "claude-agent-sdk", specifier = ">=0.1.50" }]

From 5febfd9b13d9d78e2f0cd253356badabf4e51c65 Mon Sep 17 00:00:00 2001
From: Anders <754494+andehen@users.noreply.github.com>
Date: Wed, 11 Nov 2026 09:37:09 +0100
Subject: [PATCH 239/245] feat(flags): send $experiment_exposure for v2
 experiment splits (#1154)

---
 .sampo/changesets/experiment-exposure.md      |    5 +
 posthog/args.py                               |   24 +
 posthog/async_client.py                       |   64 +-
 posthog/client.py                             |  563 ++++-
 posthog/feature_flag_evaluations.py           |   11 +
 .../feature_flag_rules_v2/SOURCE.json         |   16 +-
 ...experiment_exposure_properties.schema.json |   50 +
 .../feature_flag_called_context.schema.json   |  692 +++++++
 .../feature_flag_rules_v2/readers.json        |    8 +-
 posthog/test/released_flags_scenarios.py      |    4 +-
 posthog/test/test_experiment_exposure.py      | 1841 +++++++++++++++++
 posthog/test/test_flags_released_behaviour.py |   17 +-
 posthog/test/test_flags_v4_response.py        |   34 +-
 13 files changed, 3224 insertions(+), 105 deletions(-)
 create mode 100644 .sampo/changesets/experiment-exposure.md
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/experiment_exposure_properties.schema.json
 create mode 100644 posthog/test/fixtures/feature_flag_rules_v2/feature_flag_called_context.schema.json
 create mode 100644 posthog/test/test_experiment_exposure.py

diff --git a/.sampo/changesets/experiment-exposure.md b/.sampo/changesets/experiment-exposure.md
new file mode 100644
index 000000000..66e9d70c1
--- /dev/null
+++ b/.sampo/changesets/experiment-exposure.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Send `$experiment_exposure` for config version 2 experiment splits, and send the reason code and rule attribution on `$feature_flag_called` for config version 2 flags in place of `$feature_flag_reason`.
diff --git a/posthog/args.py b/posthog/args.py
index 42083b923..aeaf5a1d8 100644
--- a/posthog/args.py
+++ b/posthog/args.py
@@ -5,6 +5,9 @@
     Any,
     Dict,
     FrozenSet,
+    List,
+    Mapping,
+    NamedTuple,
     Union,
     Tuple,
     Type,
@@ -65,6 +68,27 @@ class OptionalCaptureArgs(TypedDict):
     _property_allowlist: NotRequired[
         Optional[FrozenSet[str]]
     ]  # Internal: strict allowlist applied to the fully-enriched event properties. Used by minimal $feature_flag_called events.
+    _pinned_properties: NotRequired[
+        Optional["_PinnedProperties"]
+    ]  # Internal: properties fixed after super properties are merged. Used by config version 2 flag events.
+    _before_send_drops: NotRequired[
+        Optional[List[str]]
+    ]  # Internal: gets the event name when before_send drops the event. Used by flag event dedupe.
+
+
+class _PinnedProperties(NamedTuple):
+    """Internal: event properties that super properties cannot change.
+
+    Applied to the fully-enriched properties, after super properties are merged and
+    before any allowlist: ``removed`` names are dropped, then ``values`` are set.
+    """
+
+    removed: FrozenSet[str]
+    values: Mapping[str, Any]
+
+    def apply(self, properties: Dict[str, Any]) -> Dict[str, Any]:
+        kept = {k: v for k, v in properties.items() if k not in self.removed}
+        return {**kept, **self.values}
 
 
 class OptionalSetArgs(TypedDict):
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 48de0abd6..7e5c3b3ff 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -38,8 +38,8 @@
 from .capture_mode import CaptureMode, _resolve_capture_mode
 from .client import (
     MAX_DICT_SIZE as _MAX_DICT_SIZE,
-    _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES,
     Client as _SyncClient,
+    _capture_flag_events,
     add_context_tags as _add_context_tags,
     get_identity_state as _get_identity_state,
     stringify_id as _stringify_id,
@@ -77,6 +77,7 @@
 )
 from .release_id import _resolve_release_id
 from .request import QuotaLimitError, determine_server_host, normalize_host
+from .types import FeatureFlag as _FeatureFlag
 from .types import (
     FlagValue,
     _has_untyped_flag_records,
@@ -196,6 +197,9 @@ def __init__(
             0, feature_flags_request_max_retries
         )
         self.distinct_ids_feature_flags_reported = SizeLimitedDict(_MAX_DICT_SIZE, set)
+        # $experiment_exposure dedupe, kept apart from $feature_flag_called's so that a
+        # reported call never suppresses its exposure. Same bound and eviction.
+        self._experiment_exposures_reported = SizeLimitedDict(_MAX_DICT_SIZE, set)
         self._feature_flag_evaluations_host_cache: Optional[
             _FeatureFlagEvaluationsHost
         ] = None
@@ -468,6 +472,7 @@ def _prepare_event(
         msg: dict[str, Any],
         disable_geoip: Optional[bool],
         property_allowlist=None,
+        pinned_properties=None,
     ) -> tuple[Optional[dict[str, Any]], Optional[str]]:
         if self.disabled or not self._accepting:
             return None, None
@@ -499,6 +504,10 @@ def _prepare_event(
             msg["properties"].setdefault("$release_id", self._release_id)
         if self.is_server:
             msg["properties"]["$is_server"] = True
+        # After every enrichment step, so a super property never changes or adds
+        # config version 2 flag attribution.
+        if pinned_properties is not None:
+            msg["properties"] = pinned_properties.apply(msg["properties"])
         if property_allowlist is not None:
             msg["properties"] = {
                 key: value
@@ -531,7 +540,7 @@ async def _process_event(self, msg: dict[str, Any]) -> Optional[dict[str, Any]]:
 
     def _build_capture_event(
         self, event: str, kwargs: OptionalCaptureArgs
-    ) -> tuple[dict[str, Any], Optional[bool], Any]:
+    ) -> tuple[dict[str, Any], Optional[bool], Any, Any]:
         properties = {**(kwargs.get("properties") or {}), **system_context()}
         if self.capture_trace_context:
             properties = {**_get_current_otel_span_properties(), **properties}
@@ -567,6 +576,7 @@ def _build_capture_event(
             },
             kwargs.get("disable_geoip"),
             kwargs.get("_property_allowlist"),
+            kwargs.get("_pinned_properties"),
         )
 
     def capture(
@@ -574,11 +584,11 @@ def capture(
     ) -> Optional[str]:
         """Queue an event without blocking for network delivery."""
         try:
-            msg, disable_geoip, property_allowlist = self._build_capture_event(
-                event, kwargs
+            msg, disable_geoip, property_allowlist, pinned_properties = (
+                self._build_capture_event(event, kwargs)
             )
             prepared, sent_uuid = self._prepare_event(
-                msg, disable_geoip, property_allowlist
+                msg, disable_geoip, property_allowlist, pinned_properties
             )
             if prepared is None or sent_uuid is None:
                 return None
@@ -622,11 +632,11 @@ async def capture_immediate(
         self._immediate_callers[current] = self._immediate_callers.get(current, 0) + 1
         error_batch: list[dict[str, Any]] = []
         try:
-            msg, disable_geoip, property_allowlist = self._build_capture_event(
-                event, kwargs
+            msg, disable_geoip, property_allowlist, pinned_properties = (
+                self._build_capture_event(event, kwargs)
             )
             prepared, sent_uuid = self._prepare_event(
-                msg, disable_geoip, property_allowlist
+                msg, disable_geoip, property_allowlist, pinned_properties
             )
             if prepared is None or sent_uuid is None:
                 return None
@@ -1090,38 +1100,29 @@ def _capture_feature_flag_called_if_needed(
         disable_geoip: Optional[bool] = None,
         has_experiment: Optional[bool] = None,
         minimal_flag_called_events: bool = False,
+        details: Optional[_FeatureFlag] = None,
+        value_from_details: bool = False,
     ) -> None:
-        groups_key = (
-            tuple(sorted((str(k), str(v)) for k, v in groups.items())) if groups else ()
-        )
-        reported_key = (key, response, groups_key)
-        reported_flags = self.distinct_ids_feature_flags_reported.get(distinct_id)
-        if reported_flags is None:
-            reported_flags = set()
-            self.distinct_ids_feature_flags_reported[distinct_id] = reported_flags
-        if reported_key in reported_flags:
-            return
-
-        if has_experiment is not None:
-            properties["$feature_flag_has_experiment"] = has_experiment
-        capture_kwargs: dict[str, Any] = {}
-        if minimal_flag_called_events and has_experiment is False:
-            capture_kwargs["_property_allowlist"] = (
-                _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
-            )
         capture_groups = {
             str(group_type): _stringify_id(group_key)
             for group_type, group_key in (groups or {}).items()
         }
-        self.capture(
-            "$feature_flag_called",
+        _capture_flag_events(
+            self.capture,
+            self.distinct_ids_feature_flags_reported,
+            self._experiment_exposures_reported,
             distinct_id=distinct_id,
+            key=key,
+            response=response,
             properties=properties,
-            groups=capture_groups,
+            groups=groups,
+            capture_groups=capture_groups,
             disable_geoip=disable_geoip,
-            **capture_kwargs,
+            has_experiment=has_experiment,
+            minimal_flag_called_events=minimal_flag_called_events,
+            details=details,
+            value_from_details=value_from_details,
         )
-        reported_flags.add(reported_key)
 
     def _pending_queue_items(self) -> int:
         return int(getattr(self._queue, "_unfinished_tasks", self._queue.qsize()))
@@ -1283,6 +1284,7 @@ async def shutdown(self) -> None:
                 errors.append(error)
 
             self.distinct_ids_feature_flags_reported.clear()
+            self._experiment_exposures_reported.clear()
             self._closed = True
             if errors and self.debug:
                 raise errors[0]
diff --git a/posthog/client.py b/posthog/client.py
index 2eb144a56..5c075da73 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -4,6 +4,7 @@
 import json
 import logging
 import os
+import re
 import sys
 import threading
 import time
@@ -11,14 +12,33 @@
 import weakref
 from contextvars import ContextVar
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union, cast
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    FrozenSet,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
 from uuid import UUID, uuid4
 
 from typing_extensions import Unpack
 
 from posthog._async_utils import _BackgroundEventLoopRunner
 from posthog._disabled_lane_queue import _DisabledLaneQueue
-from posthog.args import ID_TYPES, ExceptionArg, OptionalCaptureArgs, OptionalSetArgs
+from posthog.args import (
+    ID_TYPES,
+    ExceptionArg,
+    OptionalCaptureArgs,
+    OptionalSetArgs,
+    _PinnedProperties,
+)
 from posthog.metrics_capture import (
     _DEFAULT_FLUSH_INTERVAL_SECONDS,
     PostHogMetrics,
@@ -353,6 +373,20 @@ def wrapper(self, *args, **kwargs):
     }
 )
 
+# A config version 2 event also keeps its attribution when minimized. Only those
+# events use this wider allowlist, so a config version 1 event is trimmed as before,
+# even when super properties happen to use these names.
+_MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES: frozenset[str] = (
+    _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
+    | {
+        "$feature_flag_config_version",
+        "$feature_flag_reason_code",
+        "$feature_flag_rule_id",
+        "$feature_flag_rule_type",
+        "$feature_flag_variant_key",
+    }
+)
+
 
 def _parse_has_experiment(value: Any) -> Optional[bool]:
     """Server-reported experiment linkage; anything but an explicit bool means unknown."""
@@ -365,6 +399,401 @@ def _metadata_has_experiment(metadata: Any) -> Optional[bool]:
     return metadata.has_experiment if isinstance(metadata, FlagMetadata) else None
 
 
+# The reason code and rule type of the one outcome that sends ``$experiment_exposure``:
+# a variant assigned by an experiment rule.
+_EXPERIMENT_SPLIT_REASON = "experiment_split"
+_EXPERIMENT_RULE_TYPE = "experiment"
+
+# The reason codes of a config version 2 record that report the rule that produced
+# the result, and the rule types each one allows. Any other reason code, and any
+# failed record, reports no rule, even if the record names one.
+_RULE_TYPES_BY_REASON_CODE: Dict[str, FrozenSet[str]] = {
+    "targeting_match": frozenset({"targeted_release", "percentage_rollout"}),
+    _EXPERIMENT_SPLIT_REASON: frozenset({_EXPERIMENT_RULE_TYPE}),
+    "rollout_miss": frozenset({"percentage_rollout", _EXPERIMENT_RULE_TYPE}),
+    "experiment_paused": frozenset({_EXPERIMENT_RULE_TYPE}),
+    "holdout": frozenset({_EXPERIMENT_RULE_TYPE}),
+}
+
+# Properties a super property must not add to, or change on, a config version 2
+# ``$feature_flag_called``: the attribution, which is set again from the record
+# after super properties are merged, and the fields such an event never carries.
+# The flag identity of the read is set again with the attribution.
+_V2_FLAG_CALLED_PINNED = frozenset(
+    {
+        "$feature_flag_config_version",
+        "$feature_flag_reason_code",
+        "$feature_flag_rule_id",
+        "$feature_flag_rule_type",
+        "$feature_flag_variant_key",
+        "$feature_flag_reason",
+        "$feature_flag_forced_variant",
+        "$feature_flag_experiment_id",
+    }
+)
+
+# Properties an ``$experiment_exposure`` never carries, even from a super property.
+_EXPOSURE_FORBIDDEN = frozenset(
+    {
+        "$feature_flag_config_version",
+        "$feature_flag_reason_code",
+        "$feature_flag_rule_type",
+        "$experiment_exposure_source",
+        "$feature_flag_experiment_id",
+        "$feature_flag_forced_variant",
+    }
+)
+
+# ``$experiment_exposure`` copies these from the ``$feature_flag_called`` of the same
+# read, when it has them.
+_EXPOSURE_PROPERTIES_FROM_FLAG_CALLED = (
+    "$feature_flag_id",
+    "$feature_flag_version",
+    "$feature_flag_request_id",
+    "$feature_flag_evaluated_at",
+)
+
+
+def _v4_field(record: Any, name: str) -> Any:
+    """Read a ``/flags?v=4`` field of a parsed flag record or its metadata, such as
+    ``failed`` or ``config_version``.
+
+    These fields stay private, as ``_failed``, ``_config_version`` and so on, until
+    the typed flag accessors make them public under their wire names. Either spelling
+    is read, so the two changes can land in either order.
+    """
+    return getattr(record, name, getattr(record, f"_{name}", None))
+
+
+# The rule ID's wire format: a hyphenated UUID, as the contract's event schemas
+# require.
+_UUID_PATTERN = re.compile(
+    r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
+)
+
+
+def _is_uuid(value: Any) -> bool:
+    return isinstance(value, str) and _UUID_PATTERN.fullmatch(value) is not None
+
+
+class _RuleAttribution(NamedTuple):
+    """What a config version 2 flag record reports on its flag events."""
+
+    reason_code: Optional[str]
+    rule_id: Optional[str]
+    rule_type: Optional[str]
+    # Set only for a complete experiment split, the outcome that sends an exposure.
+    variant_key: Optional[str]
+
+    def flag_called_properties(self) -> Dict[str, Any]:
+        properties: Dict[str, Any] = {"$feature_flag_config_version": 2}
+        if self.reason_code is not None:
+            properties["$feature_flag_reason_code"] = self.reason_code
+        if self.rule_id is not None:
+            properties["$feature_flag_rule_id"] = self.rule_id
+        if self.rule_type is not None:
+            properties["$feature_flag_rule_type"] = self.rule_type
+        if self.variant_key is not None:
+            properties["$feature_flag_variant_key"] = self.variant_key
+        return properties
+
+
+def _rule_attribution(details: Optional[FeatureFlag]) -> Optional[_RuleAttribution]:
+    """Read the event attribution of a config version 2 flag record.
+
+    Returns ``None`` for anything else: no record, an unreadable record, a config
+    version 1 record, or a record from a server without typed values. Only the
+    evaluation details are read, never the value a getter returned.
+
+    The config version and reason code are always reported. The rule ID and rule
+    type are reported together or not at all, only for a targeting match, a rollout
+    miss, a paused experiment, a holdout and a complete experiment split, and only
+    with a rule type the reason code allows (``_RULE_TYPES_BY_REASON_CODE``). A
+    record with no rule ID, no rule type or another rule type, such as a targeting
+    match that names an experiment rule, reports neither. A rule ID that is not a
+    UUID counts as missing. So does a failed record or any other reason code,
+    including one this SDK does not know, and a record with no reason code. The
+    variant key is reported only for a complete experiment split: reason
+    ``experiment_split``, rule type ``experiment``, a rule ID and a variant key (any
+    string, including an empty one). A split without all of them is malformed. A
+    record that reports no rule keeps its reason, reports no rule ID, rule type or
+    variant, and sends no exposure. Its identity is never guessed from the value,
+    the key or an earlier result.
+    """
+    if details is None or not isinstance(details.metadata, FlagMetadata):
+        return None
+    metadata = details.metadata
+    if _v4_field(metadata, "config_version") != 2:
+        return None
+    reason_code = (details.reason.code if details.reason else None) or None
+    allowed_rule_types = _RULE_TYPES_BY_REASON_CODE.get(reason_code or "")
+    if _v4_field(details, "failed") is True or allowed_rule_types is None:
+        return _RuleAttribution(reason_code, None, None, None)
+    rule_id = _v4_field(metadata, "rule_id")
+    rule_type = _v4_field(metadata, "rule_type")
+    if not _is_uuid(rule_id) or rule_type not in allowed_rule_types:
+        return _RuleAttribution(reason_code, None, None, None)
+    if reason_code != _EXPERIMENT_SPLIT_REASON:
+        # Only an experiment split assigns a variant.
+        return _RuleAttribution(reason_code, rule_id, rule_type, None)
+    variant_key = _v4_field(metadata, "variant_key")
+    if not isinstance(variant_key, str):
+        return _RuleAttribution(reason_code, None, None, None)
+    return _RuleAttribution(reason_code, rule_id, rule_type, variant_key)
+
+
+_flag_events_log = logging.getLogger("posthog")
+
+# Guards the check and the reservation of config version 2 flag event dedupe keys on
+# both clients. It is held only for the dict and set operations, never while an event
+# is captured.
+_flag_event_keys_lock = threading.Lock()
+
+
+def _reinit_flag_event_keys_lock_after_fork() -> None:
+    global _flag_event_keys_lock
+    # A parent thread can hold the lock at fork time. Replace it, never acquire it.
+    _flag_event_keys_lock = threading.Lock()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(after_in_child=_reinit_flag_event_keys_lock_after_fork)
+
+
+def _reserve_dedupe_key(
+    reported_by_distinct_id: Dict[Any, Any], distinct_id: Any, dedupe_key: Any
+) -> Optional[Set[Any]]:
+    """Reserve ``dedupe_key`` for ``distinct_id`` unless a read already holds it.
+
+    The check and the reservation are one step, so when concurrent reads have the
+    same key, only one of them gets it. Returns the set that now holds the key, for
+    ``_capture_once``. Returns ``None`` when the key is already there: the event was
+    reported, or another read is capturing it.
+    """
+    with _flag_event_keys_lock:
+        reported = reported_by_distinct_id.get(distinct_id)
+        if reported is None:
+            reported = set()
+            reported_by_distinct_id[distinct_id] = reported
+        if dedupe_key in reported:
+            return None
+        reported.add(dedupe_key)
+        return reported
+
+
+def _capture_once(
+    capture: Callable[..., Any],
+    reported: Set[Any],
+    dedupe_key: Any,
+    event: str,
+    **kwargs: Any,
+) -> None:
+    """Capture one flag event whose key ``_reserve_dedupe_key`` reserved, and keep
+    the key unless capture failed.
+
+    The key stays reserved while capture runs, so concurrent reads do not send the
+    same event twice. It is released when capture raises, or returns ``None``
+    because the event could not be queued (a full or closed queue, opt-out or a
+    disabled client), so a later read tries again. An event that ``before_send``
+    drops keeps its key: the application chose to drop it, and every later read
+    would be dropped the same way. A failure is logged and never reaches the read.
+    """
+    before_send_drops: List[str] = []
+    try:
+        accepted = capture(
+            event, _before_send_drops=before_send_drops, **kwargs
+        ) is not None or bool(before_send_drops)
+    except Exception:
+        _flag_events_log.exception("[FEATURE FLAGS] Failed to capture %s", event)
+        accepted = False
+    if not accepted:
+        with _flag_event_keys_lock:
+            reported.discard(dedupe_key)
+
+
+def _capture_flag_events(
+    capture: Callable[..., Any],
+    flag_calls_reported: Dict[Any, Any],
+    exposures_reported: Dict[Any, Any],
+    *,
+    distinct_id: ID_TYPES,
+    key: str,
+    response: Optional[FlagValue],
+    properties: Dict[str, Any],
+    groups: Optional[Mapping[str, Union[str, int]]],
+    capture_groups: Mapping[str, Any],
+    disable_geoip: Optional[bool],
+    has_experiment: Optional[bool],
+    minimal_flag_called_events: bool,
+    details: Optional[FeatureFlag],
+    value_from_details: bool,
+) -> None:
+    """Send the flag events of one flag read: ``$feature_flag_called`` and, for an
+    experiment split, ``$experiment_exposure``.
+
+    Every read that sends flag events comes here, on both clients: the single-flag
+    getters and the reads of an ``evaluate_flags()`` snapshot. Both events are built
+    from ``details``, the parsed ``/flags`` record that supplied the value, and the
+    call's ``properties``; the flag is never evaluated again.
+
+    ``$feature_flag_called`` is sent if the (distinct_id, flag, response, groups)
+    tuple hasn't already been reported on this client. Group context is included so
+    that group-scoped flags fire a separate event for each group a user is evaluated
+    under. A config version 2 record that supplied the reported value
+    (``value_from_details``) adds its attribution to the event and to that tuple, so
+    equal-valued A/A arms, successive experiments of one flag, and holdouts are each
+    reported. Its reason code replaces the human-readable ``$feature_flag_reason``.
+    A config version 1 event and tuple are unchanged, and so are those of a read
+    whose value the record did not supply.
+
+    ``has_experiment`` is the server-reported signal for whether the flag is linked
+    to an experiment (``None`` when the server did not report it). When the
+    server-controlled gate is on and the flag is known non-experiment, the event is
+    trimmed to a strict allowlist; any missing signal sends the full legacy shape,
+    and experiment-linked flags keep the full set for exposure analysis.
+
+    ``minimal_flag_called_events`` is the gate as observed by the evaluation that
+    produced ``response``, not a fresh read of client-wide state: both callers
+    resolve it themselves (the snapshot pins it at construction; the single-flag
+    path reads it from the specific local/remote source that produced the value) so
+    a concurrent poller refresh or another ``/flags`` call can't reshape an event
+    after the fact.
+
+    ``$experiment_exposure`` is sent for a complete config version 2 experiment
+    split whose record supplied the reported value (``value_from_details``), once
+    per distinct ID, groups, flag, rule and variant. It has its own dedupe, so a
+    ``$feature_flag_called`` already reported never suppresses it.
+
+    Both config version 2 events are attempted independently: a failed capture of
+    one does not stop the other, and keeps no dedupe key, so a later read tries
+    again. An event that ``before_send`` drops keeps its key. Each key is reserved
+    before its capture, in the same step as the check, so concurrent reads of one
+    outcome send each event once. Their attribution is pinned after super properties
+    are merged, so a super property can neither change it nor add a field the event
+    never carries. The flag key, the response and the evaluation source are pinned
+    the same way on both events, so the pair always reports the same read.
+    Config version 1 events are sent and deduped as before.
+    """
+    groups_key = (
+        tuple(sorted((str(k), str(v)) for k, v in groups.items())) if groups else ()
+    )
+    # Only a record that supplied the reported value attributes it. A caller's
+    # match_value and a stale cached value are reported as before, with no config
+    # version 2 properties, even when a config version 2 record came with them.
+    attribution = _rule_attribution(details) if value_from_details else None
+    # What both config version 2 events report about the read itself. Each event
+    # pins it, so a super property cannot make the pair disagree.
+    flag_identity = {
+        "$feature_flag": key,
+        "$feature_flag_response": response,
+        "locally_evaluated": properties.get("locally_evaluated") is True,
+    }
+    feature_flag_reported_key: Tuple[Any, ...] = (key, response, groups_key)
+    if attribution is not None:
+        feature_flag_reported_key += (2, *attribution)
+
+    # The set this read records its $feature_flag_called key in, or None when the
+    # read sends no $feature_flag_called.
+    reported_flags: Optional[Set[Any]]
+    if attribution is None:
+        reported_flags = flag_calls_reported.get(distinct_id)
+        if reported_flags is None:
+            reported_flags = set()
+            flag_calls_reported[distinct_id] = reported_flags
+        if feature_flag_reported_key in reported_flags:
+            reported_flags = None
+    else:
+        reported_flags = _reserve_dedupe_key(
+            flag_calls_reported, distinct_id, feature_flag_reported_key
+        )
+
+    if reported_flags is not None:
+        if attribution is not None:
+            properties.pop("$feature_flag_reason", None)
+            properties.update(attribution.flag_called_properties())
+        # Record the server's experiment signal when known, so minimization's impact
+        # can be measured by segmenting on it.
+        if has_experiment is not None:
+            properties["$feature_flag_has_experiment"] = has_experiment
+
+        # Minimize iff the server-controlled gate is on AND the flag is known to have
+        # no linked experiment. Any missing signal (gate absent, has_experiment
+        # missing) fails safe to the full legacy shape.
+        should_minimize = minimal_flag_called_events and has_experiment is False
+        # Only thread the internal allowlist through when minimizing, so the
+        # full-property path's capture() call signature stays unchanged.
+        extra_capture_kwargs: Dict[str, Any] = {}
+        if should_minimize:
+            extra_capture_kwargs["_property_allowlist"] = (
+                _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
+                if attribution is None
+                else _MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES
+            )
+
+        if attribution is None:
+            # Config version 1 events are sent and deduped as before.
+            capture(
+                "$feature_flag_called",
+                distinct_id=distinct_id,
+                properties=properties,
+                groups=capture_groups,
+                disable_geoip=disable_geoip,
+                **extra_capture_kwargs,
+            )
+            reported_flags.add(feature_flag_reported_key)
+        else:
+            _capture_once(
+                capture,
+                reported_flags,
+                feature_flag_reported_key,
+                "$feature_flag_called",
+                distinct_id=distinct_id,
+                properties=properties,
+                groups=capture_groups,
+                disable_geoip=disable_geoip,
+                _pinned_properties=_PinnedProperties(
+                    _V2_FLAG_CALLED_PINNED,
+                    {**attribution.flag_called_properties(), **flag_identity},
+                ),
+                **extra_capture_kwargs,
+            )
+
+    if attribution is None or attribution.variant_key is None:
+        return
+
+    # The value, request ID, evaluation time and evaluation source are left out, so
+    # one assignment is one exposure however often it is read.
+    exposure_key = (key, groups_key, 2, attribution.rule_id, attribution.variant_key)
+    reported_exposures = _reserve_dedupe_key(
+        exposures_reported, str(distinct_id), exposure_key
+    )
+    if reported_exposures is None:
+        return
+
+    exposure_properties: Dict[str, Any] = {
+        name: properties[name]
+        for name in _EXPOSURE_PROPERTIES_FROM_FLAG_CALLED
+        if name in properties
+    }
+    exposure_identity = {
+        **flag_identity,
+        "$feature_flag_variant_key": attribution.variant_key,
+        "$feature_flag_rule_id": attribution.rule_id,
+    }
+    exposure_properties.update(exposure_identity)
+    _capture_once(
+        capture,
+        reported_exposures,
+        exposure_key,
+        "$experiment_exposure",
+        distinct_id=distinct_id,
+        properties=exposure_properties,
+        groups=capture_groups,
+        disable_geoip=disable_geoip,
+        _pinned_properties=_PinnedProperties(_EXPOSURE_FORBIDDEN, exposure_identity),
+    )
+
+
 class _Lane:
     """A capture lane: a queue drained by its own consumer pool, posting to one endpoint.
 
@@ -943,6 +1372,9 @@ def __init__(
         )
         self.poller: Optional[Poller] = None
         self.distinct_ids_feature_flags_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
+        # $experiment_exposure dedupe, kept apart from $feature_flag_called's so that a
+        # reported call never suppresses its exposure. Same bound and eviction.
+        self._experiment_exposures_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
         self.flag_fallback_cache_url = flag_fallback_cache_url
         self.flag_cache = self._initialize_flag_cache(flag_fallback_cache_url)
         self.flag_definition_version = 0
@@ -1843,6 +2275,8 @@ def _capture(
         # Internal, set for minimal $feature_flag_called events: a strict allowlist
         # applied to the fully-enriched properties dict just before enqueueing.
         property_allowlist = kwargs.get("_property_allowlist", None)
+        pinned_properties = kwargs.get("_pinned_properties", None)
+        before_send_drops = kwargs.get("_before_send_drops", None)
 
         properties = {**(properties or {}), **system_context()}
 
@@ -1960,7 +2394,12 @@ def _capture(
             msg["properties"] = properties
 
         return self._enqueue(
-            msg, disable_geoip, lane, property_allowlist=property_allowlist
+            msg,
+            disable_geoip,
+            lane,
+            property_allowlist=property_allowlist,
+            pinned_properties=pinned_properties,
+            before_send_drops=before_send_drops,
         )
 
     def _parse_send_feature_flags(self, send_feature_flags) -> SendFeatureFlagsOptions:
@@ -2569,7 +3008,15 @@ def _normalize_event_uuid(self, msg):
             # Always send a uuid, so we can always return one
             msg["uuid"] = stringify_id(uuid4())
 
-    def _enqueue(self, msg, disable_geoip, lane=None, property_allowlist=None):
+    def _enqueue(
+        self,
+        msg,
+        disable_geoip,
+        lane=None,
+        property_allowlist=None,
+        pinned_properties=None,
+        before_send_drops=None,
+    ):
         # type: (...) -> Optional[str]
         """Push a new `msg` onto a lane's queue (analytics when unspecified), return the event uuid or None."""
 
@@ -2621,6 +3068,11 @@ def _enqueue(self, msg, disable_geoip, lane=None, property_allowlist=None):
         # Applied after every enrichment step (system context, context tags, super
         # properties, $lib/$lib_version) so the final event shape is exactly the
         # allowlist regardless of where a property came from.
+        # After every enrichment step, so a super property never changes or adds
+        # config version 2 flag attribution.
+        if pinned_properties is not None:
+            msg["properties"] = pinned_properties.apply(msg["properties"])
+
         if property_allowlist is not None:
             msg["properties"] = {
                 k: v for k, v in msg["properties"].items() if k in property_allowlist
@@ -2635,6 +3087,8 @@ def _enqueue(self, msg, disable_geoip, lane=None, property_allowlist=None):
                 modified_msg = self.before_send(msg)
                 if modified_msg is None:
                     self.log.debug("Event dropped by before_send callback")
+                    if before_send_drops is not None:
+                        before_send_drops.append(msg["event"])
                     return None
                 if not isinstance(modified_msg, dict):
                     raise TypeError("before_send must return a dict or None")
@@ -3232,6 +3686,11 @@ def _shutdown_once(self, errors: list[Exception]) -> None:
             self.distinct_ids_feature_flags_reported.clear,
             errors,
         )
+        self._run_lifecycle_cleanup(
+            "Failed to clear experiment exposure deduplication state on shutdown",
+            self._experiment_exposures_reported.clear,
+            errors,
+        )
 
         if self.exception_capture:
             self._run_lifecycle_cleanup(
@@ -4102,6 +4561,9 @@ def _get_feature_flag_result(
 
         flag_result = None
         flag_details = None
+        # Whether flag_details supplied the value this read reports. Only then may the
+        # read report config version 2 attribution or send $experiment_exposure.
+        value_from_details = False
         request_id = None
         evaluated_at = None
         feature_flag_error: Optional[str] = None
@@ -4215,6 +4677,11 @@ def _get_feature_flag_result(
                 self.log.debug(
                     f"Successfully computed flag remotely: #{key} -> #{flag_result}"
                 )
+                # A payload lookup for a caller's match_value reports that value, not
+                # the record's. A failure above falls back to a stale cached value.
+                value_from_details = (
+                    flag_details is not None and override_match_value is None
+                )
             except QuotaLimitError as e:
                 self.log.warning(f"[FEATURE FLAGS] Quota limit exceeded: {e}")
                 feature_flag_error = FeatureFlagError.QUOTA_LIMITED
@@ -4276,6 +4743,7 @@ def _get_feature_flag_result(
                 minimal_flag_called_events,
                 local_flag_id=local_flag_id,
                 local_flag_version=local_flag_version,
+                value_from_details=value_from_details,
             )
 
         return flag_result
@@ -4297,6 +4765,9 @@ def get_feature_flag_result(
         Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
         depending on whether local evaluation is enabled and the flag can be locally evaluated.
         This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+        When the flag was evaluated remotely and its config version 2 record is a complete experiment
+        split (an experiment rule with a rule ID and a variant key), it also captures the
+        `$experiment_exposure` event, once per distinct ID, groups, flag, rule and variant.
 
         Examples:
             ```python
@@ -4567,6 +5038,11 @@ def _capture_feature_flag_called(
         minimal_flag_called_events: bool = False,
         local_flag_id: Optional[int] = None,
         local_flag_version: Optional[int] = None,
+        *,
+        # Keyword-only, and false by default: a caller that does not say the record
+        # supplied the value reports no config version 2 attribution and sends no
+        # $experiment_exposure.
+        value_from_details: bool = False,
     ):
         properties: dict[str, Any] = {
             "$feature_flag": key,
@@ -4607,6 +5083,8 @@ def _capture_feature_flag_called(
             disable_geoip=disable_geoip,
             has_experiment=has_experiment,
             minimal_flag_called_events=minimal_flag_called_events,
+            details=flag_details,
+            value_from_details=value_from_details,
         )
 
     def _capture_feature_flag_called_if_needed(
@@ -4620,66 +5098,35 @@ def _capture_feature_flag_called_if_needed(
         disable_geoip: Optional[bool] = None,
         has_experiment: Optional[bool] = None,
         minimal_flag_called_events: bool = False,
+        details: Optional[FeatureFlag] = None,
+        value_from_details: bool = False,
     ) -> None:
-        """Fire a ``$feature_flag_called`` event if the (distinct_id, flag, response,
-        groups) tuple hasn't already been reported on this client. Group context is
-        included so that group-scoped flags fire a separate event for each group a user
-        is evaluated under. Shared by the single-flag evaluation path and
-        ``FeatureFlagEvaluations.is_enabled() / get_flag()`` so both paths dedupe
-        identically.
-
-        ``has_experiment`` is the server-reported signal for whether the flag is linked
-        to an experiment (``None`` when the server did not report it). When the
-        server-controlled gate is on and the flag is known non-experiment, the event is
-        trimmed to a strict allowlist; any missing signal sends the full legacy shape,
-        and experiment-linked flags keep the full set for exposure analysis.
-
-        ``minimal_flag_called_events`` is the gate as observed by the evaluation that
-        produced ``response``, not a fresh read of client-wide state: both callers
-        resolve it themselves (the snapshot pins it at construction; the single-flag
-        path reads it from the specific local/remote source that produced the value)
-        so a concurrent poller refresh or another ``/flags`` call can't reshape an
-        event after the fact.
+        """Send the flag events of a flag read: ``$feature_flag_called`` and, for an
+        experiment split, ``$experiment_exposure``. See ``_capture_flag_events``.
+
+        Shared by the single-flag evaluation path and the reads of a
+        ``FeatureFlagEvaluations`` snapshot, so every read reports and dedupes
+        identically. ``details`` is the parsed ``/flags`` record of the read, or
+        ``None`` for a locally evaluated flag. ``value_from_details`` says whether that
+        record supplied the reported value; only then does the read report config
+        version 2 attribution or send an exposure.
         """
-        groups_key = (
-            tuple(sorted((str(k), str(v)) for k, v in groups.items())) if groups else ()
-        )
-        feature_flag_reported_key = (key, response, groups_key)
-
-        reported_flags = self.distinct_ids_feature_flags_reported.get(distinct_id)
-        if reported_flags is None:
-            reported_flags = set()
-            self.distinct_ids_feature_flags_reported[distinct_id] = reported_flags
-
-        if feature_flag_reported_key in reported_flags:
-            return
-
-        # Record the server's experiment signal when known, so minimization's impact
-        # can be measured by segmenting on it.
-        if has_experiment is not None:
-            properties["$feature_flag_has_experiment"] = has_experiment
-
-        # Minimize iff the server-controlled gate is on AND the flag is known to have
-        # no linked experiment. Any missing signal (gate absent, has_experiment
-        # missing) fails safe to the full legacy shape.
-        should_minimize = minimal_flag_called_events and has_experiment is False
-        # Only thread the internal allowlist through when minimizing, so the
-        # full-property path's capture() call signature stays unchanged.
-        extra_capture_kwargs: dict[str, Any] = {}
-        if should_minimize:
-            extra_capture_kwargs["_property_allowlist"] = (
-                _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
-            )
-
-        self.capture(
-            "$feature_flag_called",
+        _capture_flag_events(
+            self.capture,
+            self.distinct_ids_feature_flags_reported,
+            self._experiment_exposures_reported,
             distinct_id=distinct_id,
+            key=key,
+            response=response,
             properties=properties,
-            groups=groups or {},
+            groups=groups,
+            capture_groups=groups or {},
             disable_geoip=disable_geoip,
-            **extra_capture_kwargs,
+            has_experiment=has_experiment,
+            minimal_flag_called_events=minimal_flag_called_events,
+            details=details,
+            value_from_details=value_from_details,
         )
-        reported_flags.add(feature_flag_reported_key)
 
     def get_remote_config_payload(self, key: str):
         """
diff --git a/posthog/feature_flag_evaluations.py b/posthog/feature_flag_evaluations.py
index 1a9a170d8..8ddd10f49 100644
--- a/posthog/feature_flag_evaluations.py
+++ b/posthog/feature_flag_evaluations.py
@@ -125,6 +125,13 @@ class FeatureFlagEvaluations:
     To narrow the set of flags that get attached to a captured event, use the in-memory
     helpers :meth:`only` and :meth:`only_accessed`. To narrow the set of flags requested
     from the server in the first place, pass ``flag_keys`` to :meth:`Client.evaluate_flags`.
+
+    Reading a flag sends ``$feature_flag_called``, deduplicated as :meth:`is_enabled`
+    describes. When the flag was evaluated remotely and its config version 2 record is
+    a complete experiment split (an experiment rule with a rule ID and a variant key),
+    the read also sends ``$experiment_exposure``. The SDK sends one exposure per
+    distinct ID, groups, flag, rule and variant. ``send_feature_flag_events=False``
+    suppresses both events.
     """
 
     def __init__(
@@ -387,4 +394,8 @@ def _record_access(self, key: str, send_feature_flag_events: bool) -> None:
             properties=properties,
             has_experiment=flag.has_experiment if flag else None,
             minimal_flag_called_events=self._minimal_flag_called_events,
+            # The record that supplied the value. A remotely evaluated experiment
+            # split also sends $experiment_exposure, whatever this read returned.
+            details=flag.details if isinstance(flag, _RemoteFlagRecord) else None,
+            value_from_details=True,
         )
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json b/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
index df7f1c7e0..8274761b1 100644
--- a/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
+++ b/posthog/test/fixtures/feature_flag_rules_v2/SOURCE.json
@@ -1,14 +1,14 @@
 {
   "description": "Copied unchanged from the released feature flag rules v2 contract in PostHog/posthog-sdk-test-harness. Do not edit these files; copy a newer release instead.",
   "repository": "https://github.com/PostHog/posthog-sdk-test-harness",
-  "release": "1.22.0",
-  "revision": "17d861f8e230fe943934d70e3eebf5cff6bf3aa4",
+  "release": "1.30.0",
+  "revision": "6414114501396d96aadf2412fdd8054a03076782",
   "contract_directory": "contracts/feature_flag_rules_v2",
-  "contract_version": "7.0.0",
+  "contract_version": "10.0.0",
   "files": {
     "readers.json": {
       "source_path": "fixtures/wire/readers.json",
-      "sha256": "fd8edd89f827b732c4659ce7246eab534b0106b96a465a4a2d98cfa0a17d7827"
+      "sha256": "e75abb9bf6656989a147dda4c6e5232e7b544b657d7d540164dce65688641501"
     },
     "responses.json": {
       "source_path": "fixtures/wire/responses.json",
@@ -21,6 +21,14 @@
     "v2_value_evaluation.json": {
       "source_path": "corpus/v2_value_evaluation.json",
       "sha256": "aaddd05e47fc5a4ae07ea42ada5a659798f4b5fc8d0c0827f6a68e4daf68c128"
+    },
+    "feature_flag_called_context.schema.json": {
+      "source_path": "schemas/feature_flag_called_context.schema.json",
+      "sha256": "8a475f5ab56ba4dba76501c4a4e23f26b62c2c2f8037f23d21d0ea7650bd2cf8"
+    },
+    "experiment_exposure_properties.schema.json": {
+      "source_path": "schemas/experiment_exposure_properties.schema.json",
+      "sha256": "4b1af8fc98b6f6cb49f974970eb289ca85a78a978e1e74fc4d417eee9adee449"
     }
   }
 }
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/experiment_exposure_properties.schema.json b/posthog/test/fixtures/feature_flag_rules_v2/experiment_exposure_properties.schema.json
new file mode 100644
index 000000000..ee8604e38
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/experiment_exposure_properties.schema.json
@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://posthog.com/contracts/feature_flag_rules_v2/experiment_exposure_properties.schema.json",
+  "title": "SDK-sent $experiment_exposure properties",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "$feature_flag",
+    "$feature_flag_response",
+    "$feature_flag_variant_key",
+    "$feature_flag_rule_id",
+    "locally_evaluated"
+  ],
+  "properties": {
+    "$feature_flag": {
+      "type": "string",
+      "minLength": 1
+    },
+    "$feature_flag_response": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        }
+      ]
+    },
+    "$feature_flag_variant_key": {
+      "type": "string"
+    },
+    "$feature_flag_rule_id": {
+      "type": "string",
+      "format": "uuid"
+    },
+    "locally_evaluated": {
+      "type": "boolean"
+    },
+    "$feature_flag_forced_variant": {
+      "const": true
+    }
+  },
+  "description": "Closed projection of the properties of an SDK-sent exposure. The SDK sends it only for a config version 2 experiment split, so it carries no config version, rule type, reason code or source marker; the rule ID marks it as SDK-sent. Experiment ID and forced-variant context are forbidden. Capture identity and existing optional transport properties are outside this projection. Scan the entire event recursively for assignment seeds.",
+  "not": {
+    "required": [
+      "$feature_flag_forced_variant"
+    ]
+  }
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/feature_flag_called_context.schema.json b/posthog/test/fixtures/feature_flag_rules_v2/feature_flag_called_context.schema.json
new file mode 100644
index 000000000..1829dde76
--- /dev/null
+++ b/posthog/test/fixtures/feature_flag_rules_v2/feature_flag_called_context.schema.json
@@ -0,0 +1,692 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://posthog.com/contracts/feature_flag_rules_v2/feature_flag_called_context.schema.json",
+  "title": "$feature_flag_called context properties",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "$feature_flag",
+    "$feature_flag_response"
+  ],
+  "properties": {
+    "$feature_flag": {
+      "type": "string",
+      "minLength": 1
+    },
+    "$feature_flag_response": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        }
+      ]
+    },
+    "$feature_flag_config_version": {
+      "enum": [
+        1,
+        2
+      ]
+    },
+    "$feature_flag_variant_key": {
+      "type": "string"
+    },
+    "$feature_flag_rule_id": {
+      "type": "string",
+      "format": "uuid"
+    },
+    "$feature_flag_rule_type": {
+      "enum": [
+        "targeted_release",
+        "percentage_rollout",
+        "experiment"
+      ]
+    },
+    "$feature_flag_experiment_id": {
+      "type": "integer"
+    },
+    "$feature_flag_reason_code": {
+      "type": "string",
+      "minLength": 1
+    },
+    "$feature_flag_reason": {},
+    "$feature_flag_forced_variant": {
+      "const": true
+    }
+  },
+  "description": "Closed projection of the flag-access context properties. Other existing capture fields are outside this projection. Complete v2 producer context follows the terminal outcome. A tolerant reader drops the whole attribution of a record that breaks its reason's rows (a rule ID without its rule type or the reverse, a rule type the reason does not allow, or a malformed split): for every reason that names a rule, a call may keep the config version and reason code and omit all rule, variant and experiment attribution, while a partly populated or mismatched tuple is rejected. A config version 2 call whose reason code is missing or not registered keeps the raw code, if any, and carries no attribution; a registered code only matches its own reason's branches. A config version 2 call never carries $feature_flag_reason, the reason description that only version 1 calls carry.",
+  "allOf": [
+    {
+      "if": {
+        "required": [
+          "$feature_flag_config_version"
+        ],
+        "properties": {
+          "$feature_flag_config_version": {
+            "const": 2
+          }
+        }
+      },
+      "then": {
+        "not": {
+          "anyOf": [
+            {
+              "required": [
+                "$feature_flag_forced_variant"
+              ]
+            },
+            {
+              "required": [
+                "$feature_flag_reason"
+              ]
+            }
+          ]
+        },
+        "oneOf": [
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "targeting_match"
+              },
+              "$feature_flag_rule_type": {
+                "const": "targeted_release"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "targeting_match"
+              },
+              "$feature_flag_rule_type": {
+                "const": "percentage_rollout"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "experiment_split"
+              },
+              "$feature_flag_rule_type": {
+                "const": "experiment"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id",
+              "$feature_flag_variant_key"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "rollout_miss"
+              },
+              "$feature_flag_rule_type": {
+                "const": "percentage_rollout"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "rollout_miss"
+              },
+              "$feature_flag_rule_type": {
+                "const": "experiment"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "experiment_paused"
+              },
+              "$feature_flag_rule_type": {
+                "const": "experiment"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "holdout"
+              },
+              "$feature_flag_rule_type": {
+                "const": "experiment"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code",
+              "$feature_flag_rule_type",
+              "$feature_flag_rule_id"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "no_rule_match"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "missing_group_key"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "dependency_error"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "error"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "targeting_match"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "experiment_split"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "rollout_miss"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "experiment_paused"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "holdout"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "properties": {
+              "$feature_flag_reason_code": {
+                "not": {
+                  "enum": [
+                    "targeting_match",
+                    "experiment_split",
+                    "rollout_miss",
+                    "experiment_paused",
+                    "holdout",
+                    "no_rule_match",
+                    "missing_group_key",
+                    "dependency_error",
+                    "error",
+                    "flag_disabled"
+                  ]
+                }
+              }
+            },
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            "description": "A local-only outcome with no matrix row: the server never returns flag_disabled, and the call carries no rule or experiment attribution.",
+            "properties": {
+              "$feature_flag_reason_code": {
+                "const": "flag_disabled"
+              }
+            },
+            "required": [
+              "$feature_flag_reason_code"
+            ],
+            "not": {
+              "anyOf": [
+                {
+                  "required": [
+                    "$feature_flag_rule_type"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_rule_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_experiment_id"
+                  ]
+                },
+                {
+                  "required": [
+                    "$feature_flag_variant_key"
+                  ]
+                }
+              ]
+            }
+          }
+        ]
+      },
+      "else": {
+        "not": {
+          "anyOf": [
+            {
+              "required": [
+                "$feature_flag_rule_id"
+              ]
+            },
+            {
+              "required": [
+                "$feature_flag_rule_type"
+              ]
+            }
+          ]
+        }
+      }
+    }
+  ]
+}
diff --git a/posthog/test/fixtures/feature_flag_rules_v2/readers.json b/posthog/test/fixtures/feature_flag_rules_v2/readers.json
index 7ed8c252b..add97e172 100644
--- a/posthog/test/fixtures/feature_flag_rules_v2/readers.json
+++ b/posthog/test/fixtures/feature_flag_rules_v2/readers.json
@@ -992,7 +992,10 @@
         "value": "compact",
         "config_version": 1,
         "experiment_exposure": false,
-        "error_code": null
+        "error_code": null,
+        "legacy_payload": {
+          "columns": 2
+        }
       },
       "producer_expected": "valid"
     },
@@ -1018,7 +1021,8 @@
         "value": true,
         "config_version": 1,
         "experiment_exposure": false,
-        "error_code": "GENERAL"
+        "error_code": "GENERAL",
+        "legacy_payload": null
       },
       "producer_expected": "valid"
     },
diff --git a/posthog/test/released_flags_scenarios.py b/posthog/test/released_flags_scenarios.py
index a1fccb10c..2e8246191 100644
--- a/posthog/test/released_flags_scenarios.py
+++ b/posthog/test/released_flags_scenarios.py
@@ -31,6 +31,7 @@
 )
 API_KEY = "phc_released_flags_scenarios"
 DISTINCT_ID = "user-1"
+ACCEPTED_UUID = "70000000-0000-4000-8000-000000000000"
 REQUEST_ID = "60000000-0000-4000-8000-000000000000"
 EVALUATED_AT = 1800000000000
 MATCHED = {
@@ -171,7 +172,8 @@ def flags(*args: Any, **kwargs: Any) -> Any:
 
     def enqueue(message: Dict[str, Any], *args: Any, **kwargs: Any) -> Optional[str]:
         events.append([message["event"], _flag_event_properties(message)])
-        return None
+        # Accept the event, as the real queue does, by returning an event UUID.
+        return ACCEPTED_UUID
 
     try:
         with (
diff --git a/posthog/test/test_experiment_exposure.py b/posthog/test/test_experiment_exposure.py
new file mode 100644
index 000000000..c12152833
--- /dev/null
+++ b/posthog/test/test_experiment_exposure.py
@@ -0,0 +1,1841 @@
+"""``$experiment_exposure`` and the attribution of ``$feature_flag_called``.
+
+A remotely evaluated config version 2 record that assigns an experiment variant sends
+``$experiment_exposure`` next to its ``$feature_flag_called``, and every config version
+2 record adds its rule attribution to ``$feature_flag_called``. The reader fixtures and
+event schemas are copied unchanged from a ``PostHog/posthog-sdk-test-harness`` contract;
+``fixtures/feature_flag_rules_v2/SOURCE.json`` records which.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import threading
+import warnings
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional
+from unittest import mock
+
+import jsonschema
+import pytest
+
+from posthog import AsyncPosthog
+from posthog import client as posthog_client
+from posthog.client import (
+    _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES,
+    _MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES,
+    MAX_DICT_SIZE,
+    Client,
+)
+from posthog.test.test_flags_v4_response import FIXTURES, READERS, _build
+from posthog.test.test_utils import FAKE_TEST_API_KEY
+from posthog.types import FeatureFlagResult
+from posthog.utils import SizeLimitedDict
+
+FLAG = "pricing-page"
+DISTINCT_ID = "visitor-42"
+RULE = "7f3c2a10-8d4e-4b6a-9c21-5e0f1a2b3c4d"
+OTHER_RULE = "2b9d4e61-0c7a-4f35-8e12-6a4b3c2d1e0f"
+REQUEST_ID = "5d1e2f30-4a5b-4c6d-8e7f-90a1b2c3d4e5"
+OTHER_REQUEST_ID = "6e2f3a41-5b6c-4d7e-9f80-a1b2c3d4e5f6"
+EVALUATED_AT = 1_800_000_000_000
+
+EXPOSURE = "$experiment_exposure"
+FLAG_CALLED = "$feature_flag_called"
+ATTRIBUTION_PROPERTIES = (
+    "$feature_flag_config_version",
+    "$feature_flag_reason_code",
+    "$feature_flag_rule_id",
+    "$feature_flag_rule_type",
+    "$feature_flag_variant_key",
+)
+
+
+# $experiment_exposure leaves these out. The config version, rule type and reason code
+# stay on the $feature_flag_called of the same read. The schema projection drops
+# undeclared properties, so their absence is asserted separately.
+EXPOSURE_LEAVES_OUT = (
+    "$feature_flag_config_version",
+    "$feature_flag_rule_type",
+    "$feature_flag_reason_code",
+    "$experiment_exposure_source",
+)
+
+
+def _schema(name: str) -> jsonschema.Draft202012Validator:
+    schema = json.loads((FIXTURES / name).read_text(encoding="utf-8"))
+    return jsonschema.Draft202012Validator(schema)
+
+
+FLAG_CALLED_SCHEMA = _schema("feature_flag_called_context.schema.json")
+EXPOSURE_SCHEMA = _schema("experiment_exposure_properties.schema.json")
+
+
+def _projection(
+    validator: jsonschema.Draft202012Validator, properties: Mapping[str, Any]
+) -> Dict[str, Any]:
+    """The properties a closed contract projection covers."""
+    names = validator.schema["properties"]
+    return {key: value for key, value in properties.items() if key in names}
+
+
+# --- Responses ----------------------------------------------------------------
+
+
+def _record(
+    code: str,
+    value: Any = True,
+    *,
+    key: str = FLAG,
+    rule_type: Optional[str] = None,
+    rule_id: Optional[str] = None,
+    variant_key: Optional[str] = None,
+    config_version: int = 2,
+    has_experiment: bool = False,
+    description: Optional[str] = None,
+    failed: bool = False,
+) -> Dict[str, Any]:
+    metadata: Dict[str, Any] = {
+        "id": 77,
+        "version": 3,
+        "config_version": config_version,
+        "description": None,
+        "payload": None,
+        "has_experiment": has_experiment,
+    }
+    for field, field_value in (
+        ("rule_type", rule_type),
+        ("rule_id", rule_id),
+        ("variant_key", variant_key),
+    ):
+        if field_value is not None:
+            metadata[field] = field_value
+    reason: Dict[str, Any] = {
+        "code": code,
+        "condition_index": 0 if rule_id else None,
+    }
+    if description is not None:
+        reason["description"] = description
+    record = {"key": key, "value": value, "reason": reason, "metadata": metadata}
+    if failed:
+        record["failed"] = True
+    return record
+
+
+def _split(
+    value: Any = "annual",
+    variant_key: str = "annual-first",
+    rule_id: str = RULE,
+    **overrides: Any,
+) -> Dict[str, Any]:
+    fields: Dict[str, Any] = {
+        "rule_type": "experiment",
+        "rule_id": rule_id,
+        "variant_key": variant_key,
+        "has_experiment": True,
+        **overrides,
+    }
+    return _record("experiment_split", value, **fields)
+
+
+def _response(
+    *records: Dict[str, Any],
+    request_id: str = REQUEST_ID,
+    evaluated_at: int = EVALUATED_AT,
+    **envelope: Any,
+) -> Dict[str, Any]:
+    return {
+        "flags": {record["key"]: record for record in records},
+        "errorsWhileComputingFlags": False,
+        "requestId": request_id,
+        "evaluatedAt": evaluated_at,
+        **envelope,
+    }
+
+
+# --- Recording events -----------------------------------------------------------
+
+
+@dataclass
+class _Event:
+    name: str
+    distinct_id: Any
+    properties: Dict[str, Any]
+    groups: Any
+    property_allowlist: Any
+    uuid: Optional[str]
+
+
+def _record_events(client: Any) -> tuple[Any, List[_Event]]:
+    """Patch ``client.capture`` to record each call, then capture as usual."""
+    events: List[_Event] = []
+    capture = client.capture
+
+    def record(event: str, **kwargs: Any) -> Optional[str]:
+        uuid = capture(event, **kwargs)
+        events.append(
+            _Event(
+                name=event,
+                distinct_id=kwargs.get("distinct_id"),
+                properties=copy.deepcopy(kwargs.get("properties") or {}),
+                groups=kwargs.get("groups"),
+                property_allowlist=kwargs.get("_property_allowlist"),
+                uuid=uuid,
+            )
+        )
+        return uuid
+
+    return mock.patch.object(client, "capture", side_effect=record), events
+
+
+def _named(events: List[_Event], name: str, key: str = FLAG) -> List[_Event]:
+    return [
+        event
+        for event in events
+        if event.name == name and event.properties.get("$feature_flag") == key
+    ]
+
+
+def _attribution(properties: Mapping[str, Any]) -> Dict[str, Any]:
+    return {
+        name: properties[name] for name in ATTRIBUTION_PROPERTIES if name in properties
+    }
+
+
+# --- Reading through each path ------------------------------------------------------
+
+# Every sync read that sends flag events. Each takes the client, the key, the
+# distinct ID and the groups.
+SYNC_READS: Dict[str, Callable[..., Any]] = {
+    "get_feature_flag": lambda client, key, distinct_id, groups: (
+        client.get_feature_flag(key, distinct_id, groups=groups)
+    ),
+    "feature_enabled": lambda client, key, distinct_id, groups: (
+        client.feature_enabled(key, distinct_id, groups=groups)
+    ),
+    "get_feature_flag_result": lambda client, key, distinct_id, groups: (
+        client.get_feature_flag_result(key, distinct_id, groups=groups)
+    ),
+    "snapshot.get_flag": lambda client, key, distinct_id, groups: (
+        client.evaluate_flags(distinct_id, groups=groups).get_flag(key)
+    ),
+    "snapshot.is_enabled": lambda client, key, distinct_id, groups: (
+        client.evaluate_flags(distinct_id, groups=groups).is_enabled(key)
+    ),
+}
+SINGLE_FLAG_READS = ["get_feature_flag", "feature_enabled", "get_feature_flag_result"]
+SNAPSHOT_READS = ["snapshot.get_flag", "snapshot.is_enabled"]
+
+
+@pytest.fixture
+def client() -> Iterator[Client]:
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    yield client
+    client.shutdown()
+
+
+def _serving(*responses: Dict[str, Any]) -> Any:
+    """Patch ``/flags`` to answer with each response in turn, the last one after that."""
+    remaining = list(responses)
+
+    def answer(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        response = remaining.pop(0) if len(remaining) > 1 else remaining[0]
+        return copy.deepcopy(response)
+
+    return mock.patch("posthog.client.flags", side_effect=answer)
+
+
+def _read(
+    client: Client,
+    path: str,
+    key: str = FLAG,
+    distinct_id: Any = DISTINCT_ID,
+    groups: Optional[Dict[str, Any]] = None,
+) -> Any:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        return SYNC_READS[path](client, key, distinct_id, groups or {})
+
+
+def _read_events(
+    path: str,
+    *responses: Dict[str, Any],
+    reads: int = 1,
+    client: Optional[Client] = None,
+    **read_kwargs: Any,
+) -> List[_Event]:
+    """Read ``FLAG`` ``reads`` times through ``path``, one response per read."""
+    own_client = client is None
+    client = client or Client(FAKE_TEST_API_KEY, send=False)
+    recording, events = _record_events(client)
+    try:
+        with _serving(*responses), recording:
+            for _ in range(reads):
+                _read(client, path, **read_kwargs)
+    finally:
+        if own_client:
+            client.shutdown()
+    return events
+
+
+async def _read_async_events(
+    responses: List[Dict[str, Any]],
+    reads: List[Callable[[Any], Any]],
+) -> List[_Event]:
+    """Run the reads on one async client, answering each evaluation with the next
+    response, and the last one after that."""
+    remaining = list(responses)
+
+    def answer(*args: Any, **kwargs: Any) -> Dict[str, Any]:
+        response = remaining.pop(0) if len(remaining) > 1 else remaining[0]
+        return copy.deepcopy(response)
+
+    with mock.patch(
+        "posthog.async_client._async_flags", new=mock.AsyncMock(side_effect=answer)
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        recording, events = _record_events(client)
+        with recording:
+            for read in reads:
+                await read(client)
+        await client.shutdown()
+    return events
+
+
+# --- The contract's reader cases --------------------------------------------------------
+
+READER_CASES = [case for case in READERS["cases"] if case["expected"] == "reader"]
+
+
+def _check_reader_events(case: Dict[str, Any], events: List[_Event]) -> None:
+    reader = case["reader"]
+    expectations = {reader["requested_key"]: reader}
+    expectations.update(case.get("sibling_expectations", {}))
+    for key, expected in expectations.items():
+        exposures = _named(events, EXPOSURE, key)
+        assert len(exposures) == (1 if expected["experiment_exposure"] else 0), key
+        [called] = _named(events, FLAG_CALLED, key)
+        config_version = expected.get("config_version")
+        if expected.get("error_code") == "PARSE_ERROR":
+            config_version = None
+        assert called.properties.get("$feature_flag_config_version") == (
+            2 if config_version == 2 else None
+        ), key
+        if called.properties["$feature_flag_response"] is not None:
+            FLAG_CALLED_SCHEMA.validate(
+                _projection(FLAG_CALLED_SCHEMA, called.properties)
+            )
+        for exposure in exposures:
+            EXPOSURE_SCHEMA.validate(_projection(EXPOSURE_SCHEMA, exposure.properties))
+            assert not set(EXPOSURE_LEAVES_OUT) & set(exposure.properties), key
+            assert (
+                exposure.properties["$feature_flag_response"]
+                == (called.properties["$feature_flag_response"])
+            )
+            assert exposure.uuid is not None and exposure.uuid != called.uuid
+        for event in [called, *exposures]:
+            # A flag may be named anything, so `$feature/<key>` is left out.
+            for name in event.properties:
+                if not name.startswith("$feature/"):
+                    for part in ("experiment_id", "holdout", "seed"):
+                        assert part not in name, name
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+@pytest.mark.parametrize("case", READER_CASES, ids=lambda case: case["id"])
+def test_reader_cases_send_an_exposure_exactly_when_the_contract_expects(case, path):
+    response = _build(READERS, case)
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    recording, events = _record_events(client)
+    try:
+        with _serving(response), recording:
+            _read(client, path, case["reader"]["requested_key"])
+            for sibling in case.get("sibling_expectations", {}):
+                _read(client, path, sibling)
+    finally:
+        client.shutdown()
+
+    _check_reader_events(case, events)
+
+
+@pytest.mark.parametrize("method", ["get_flag", "is_enabled"])
+@pytest.mark.parametrize("case", READER_CASES, ids=lambda case: case["id"])
+async def test_async_reader_cases_send_an_exposure_exactly_when_the_contract_expects(
+    case, method
+):
+    keys = [case["reader"]["requested_key"], *case.get("sibling_expectations", {})]
+
+    async def read(client: Any) -> None:
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        for key in keys:
+            getattr(snapshot, method)(key)
+
+    events = await _read_async_events([_build(READERS, case)], [read])
+
+    _check_reader_events(case, events)
+
+
+# --- Attribution on $feature_flag_called --------------------------------------------------
+
+_RULE_ID = "10000000-0000-4000-8000-000000000001"
+ATTRIBUTION_CASES = [
+    # (reader template or case id, attribution on $feature_flag_called)
+    (
+        "experiment_split",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "experiment_split",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "experiment",
+            "$feature_flag_variant_key": "arm_a",
+        },
+    ),
+    (
+        "targeting_match_targeted_release",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "targeting_match",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "targeted_release",
+        },
+    ),
+    (
+        "targeting_match_percentage_rollout",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "targeting_match",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "percentage_rollout",
+        },
+    ),
+    (
+        "rollout_miss_percentage_rollout",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "rollout_miss",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "percentage_rollout",
+        },
+    ),
+    (
+        "rollout_miss_experiment",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "rollout_miss",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "experiment",
+        },
+    ),
+    (
+        "experiment_paused",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "experiment_paused",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "experiment",
+        },
+    ),
+    (
+        "holdout",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "holdout",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "experiment",
+        },
+    ),
+    # A holdout assigns no variant, even when its record names one.
+    (
+        "readers.holdout_variant_key",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "holdout",
+            "$feature_flag_rule_id": _RULE_ID,
+            "$feature_flag_rule_type": "experiment",
+        },
+    ),
+    (
+        "no_rule_match",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "no_rule_match",
+        },
+    ),
+    (
+        "missing_group_key",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "missing_group_key",
+        },
+    ),
+    (
+        "dependency_error",
+        {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": "dependency_error",
+        },
+    ),
+    (
+        "error",
+        {"$feature_flag_config_version": 2, "$feature_flag_reason_code": "error"},
+    ),
+    # A malformed split keeps its config version and reason, and loses the whole rule
+    # tuple.
+    *(
+        (
+            case_id,
+            {
+                "$feature_flag_config_version": 2,
+                "$feature_flag_reason_code": "experiment_split",
+            },
+        )
+        for case_id in (
+            "readers.partial_split_missing_rule_type",
+            "readers.partial_split_missing_rule_id",
+            "readers.partial_split_missing_variant_key",
+            "readers.wrong_rule_type_literal",
+            "readers.partial_split_string_value",
+        )
+    ),
+    # Config version 1, from either kind of server, is unchanged.
+    ("v1", {}),
+    ("old_server", {}),
+    ("readers.partial_split_missing_config_version", {}),
+]
+
+
+def _attribution_response(source: str) -> Dict[str, Any]:
+    if source.startswith("readers."):
+        [case] = [case for case in READERS["cases"] if case["id"] == source]
+        return _build(READERS, case)
+    return _build(READERS, {"template": source})
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize(
+    "source, expected", ATTRIBUTION_CASES, ids=[c[0] for c in ATTRIBUTION_CASES]
+)
+def test_flag_called_attribution_follows_the_record(source, expected, path):
+    events = _read_events(path, _attribution_response(source), key="garden-layout")
+
+    [called] = _named(events, FLAG_CALLED, "garden-layout")
+    assert _attribution(called.properties) == expected
+    FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+    exposures = _named(events, EXPOSURE, "garden-layout")
+    assert len(exposures) == (1 if "$feature_flag_variant_key" in expected else 0)
+
+
+# A record whose reason names no rule, or that failed, reports no rule even when it
+# carries one. Neither sends an exposure. The last element says whether the record is
+# a valid server outcome, which the contract's event schema then accepts.
+STRAY_RULE_CASES = [
+    ("no_rule_match", {}, True),
+    ("missing_group_key", {}, True),
+    ("flag_disabled", {}, True),
+    ("dependency_error", {"failed": True, "value": None}, True),
+    ("error", {"failed": True, "value": None}, True),
+    # A failed record reports no rule, whatever its reason code.
+    (
+        "experiment_split",
+        {"failed": True, "value": None, "variant_key": "annual-first"},
+        True,
+    ),
+    ("holdout", {"failed": True, "value": None}, False),
+    # A reason code this SDK does not know.
+    ("future_reason", {}, False),
+]
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize(
+    "code, fields, valid_outcome",
+    STRAY_RULE_CASES,
+    ids=[f"{c}-{sorted(f)}" for c, f, _ in STRAY_RULE_CASES],
+)
+def test_rule_fields_are_sent_only_for_reasons_that_name_a_rule(
+    code, fields, valid_outcome, path
+):
+    fields = {"value": False, **fields}
+    record = _record(
+        code, rule_type="experiment", rule_id=RULE, has_experiment=True, **fields
+    )
+
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert _attribution(called.properties) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": code,
+    }
+    assert _named(events, EXPOSURE) == []
+    if valid_outcome:
+        FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+@pytest.mark.parametrize("method", ["get_flag", "is_enabled"])
+async def test_async_a_failed_split_sends_no_exposure(method):
+    # The record keeps its complete split metadata, but it failed.
+    record = _split(value=None, failed=True)
+
+    async def read(client: Any) -> None:
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        getattr(snapshot, method)(FLAG)
+
+    events = await _read_async_events([_response(record)], [read])
+
+    [called] = _named(events, FLAG_CALLED)
+    assert _attribution(called.properties) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": "experiment_split",
+    }
+    assert _named(events, EXPOSURE) == []
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize(
+    "code, rule_type",
+    [
+        ("targeting_match", "targeted_release"),
+        ("targeting_match", "percentage_rollout"),
+        ("rollout_miss", "percentage_rollout"),
+        ("rollout_miss", "experiment"),
+        ("experiment_paused", "experiment"),
+        ("holdout", "experiment"),
+    ],
+)
+def test_rule_matches_misses_pauses_and_holdouts_name_their_rule(code, rule_type, path):
+    record = _record(code, False, rule_type=rule_type, rule_id=RULE)
+
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert _attribution(called.properties) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": code,
+        "$feature_flag_rule_id": RULE,
+        "$feature_flag_rule_type": rule_type,
+    }
+    assert _named(events, EXPOSURE) == []
+    FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+# The rule ID and rule type are sent together, with a rule type the reason allows, or
+# not at all. A call that drops a broken pair keeps its config version and reason code.
+BROKEN_RULE_PAIR_CASES = [
+    # Half pairs.
+    ("targeting_match", {"rule_id": RULE}),
+    ("rollout_miss", {"rule_id": RULE}),
+    ("experiment_paused", {"rule_id": RULE}),
+    ("holdout", {"rule_id": RULE}),
+    ("targeting_match", {"rule_type": "targeted_release"}),
+    ("rollout_miss", {"rule_type": "percentage_rollout"}),
+    ("experiment_paused", {"rule_type": "experiment"}),
+    ("holdout", {"rule_type": "experiment"}),
+    # Rule types the reason code does not allow.
+    ("targeting_match", {"rule_id": RULE, "rule_type": "experiment"}),
+    ("rollout_miss", {"rule_id": RULE, "rule_type": "targeted_release"}),
+    ("experiment_paused", {"rule_id": RULE, "rule_type": "percentage_rollout"}),
+    ("holdout", {"rule_id": RULE, "rule_type": "targeted_release"}),
+    # A rule type this SDK does not know.
+    ("targeting_match", {"rule_id": RULE, "rule_type": "future_rule_type"}),
+]
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize(
+    "code, fields",
+    BROKEN_RULE_PAIR_CASES,
+    ids=[f"{c}-{sorted(f.items())}" for c, f in BROKEN_RULE_PAIR_CASES],
+)
+def test_a_half_or_disallowed_rule_pair_is_not_sent(code, fields, path):
+    record = _record(code, False, **fields)
+
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert _attribution(called.properties) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": code,
+    }
+    assert _named(events, EXPOSURE) == []
+    FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_a_targeting_match_that_names_an_experiment_rule_sends_no_exposure(path):
+    # Even with a variant key and a linked experiment, a targeting match assigns no
+    # arm, so it reports no rule and sends no exposure.
+    record = _record(
+        "targeting_match",
+        "annual",
+        rule_type="experiment",
+        rule_id=RULE,
+        variant_key="annual-first",
+        has_experiment=True,
+    )
+
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert _attribution(called.properties) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": "targeting_match",
+    }
+    assert _named(events, EXPOSURE) == []
+    FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+def test_an_older_server_record_reports_no_attribution():
+    # A record without a typed value comes from a server before /flags?v=4. Its
+    # metadata is not read as config version 2, whatever it says.
+    response = _response(
+        {
+            "key": FLAG,
+            "enabled": True,
+            "variant": "annual",
+            "reason": {"code": "condition_match", "condition_index": 0},
+            "metadata": {
+                "id": 77,
+                "version": 3,
+                "config_version": 2,
+                "rule_type": "experiment",
+                "rule_id": RULE,
+                "variant_key": "annual-first",
+            },
+        }
+    )
+    for path in SYNC_READS:
+        events = _read_events(path, response)
+        [called] = _named(events, FLAG_CALLED)
+        assert _attribution(called.properties) == {}
+        assert _named(events, EXPOSURE) == []
+
+
+# --- $feature_flag_reason ------------------------------------------------------------------
+
+REASON_DESCRIPTION = "Matched rule 1"
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+@pytest.mark.parametrize(
+    "record",
+    [
+        _record(
+            "targeting_match",
+            rule_type="targeted_release",
+            rule_id=RULE,
+            description=REASON_DESCRIPTION,
+        ),
+        _record("no_rule_match", False, description=REASON_DESCRIPTION),
+        _record("error", None, failed=True, description=REASON_DESCRIPTION),
+        _split(description=REASON_DESCRIPTION),
+    ],
+    ids=["targeting_match", "no_rule_match", "failed", "experiment_split"],
+)
+def test_a_config_version_2_call_reports_its_reason_by_code_only(record, path):
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert called.properties["$feature_flag_reason_code"] == record["reason"]["code"]
+    assert "$feature_flag_reason" not in called.properties
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+@pytest.mark.parametrize(
+    "record",
+    [
+        _record(
+            "condition_match",
+            "annual",
+            config_version=1,
+            description=REASON_DESCRIPTION,
+        ),
+        # A record from a server before /flags?v=4, which has no config version.
+        {
+            "key": FLAG,
+            "enabled": True,
+            "variant": "annual",
+            "reason": {
+                "code": "condition_match",
+                "condition_index": 0,
+                "description": REASON_DESCRIPTION,
+            },
+            "metadata": {"id": 77, "version": 3},
+        },
+    ],
+    ids=["config_version_1", "older_server"],
+)
+def test_a_call_without_config_version_2_keeps_its_reason_description(record, path):
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert called.properties["$feature_flag_reason"] == REASON_DESCRIPTION
+    assert _attribution(called.properties) == {}
+
+
+@pytest.mark.parametrize(
+    "config_version, code, reason",
+    [(1, "condition_match", REASON_DESCRIPTION), (2, "targeting_match", None)],
+)
+def test_minimal_calls_keep_the_reason_description_only_without_config_version_2(
+    config_version, code, reason
+):
+    messages: List[Dict[str, Any]] = []
+
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        messages.append(message)
+        return message
+
+    client = Client(FAKE_TEST_API_KEY, send=False, before_send=before_send)
+    record = _record(
+        code, config_version=config_version, description=REASON_DESCRIPTION
+    )
+    try:
+        with _serving(_response(record, minimalFlagCalledEvents=True)):
+            client.evaluate_flags(DISTINCT_ID).get_flag(FLAG)
+            client.get_feature_flag_result(FLAG, "visitor-43")
+    finally:
+        client.shutdown()
+
+    allowlist = (
+        _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
+        if config_version == 1
+        else _MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES
+    )
+    assert [message["event"] for message in messages] == [FLAG_CALLED, FLAG_CALLED]
+    for message in messages:
+        assert set(message["properties"]) <= allowlist
+        assert message["properties"].get("$feature_flag_reason") == reason
+
+
+def test_minimal_config_version_1_calls_drop_super_properties_named_like_attribution():
+    attribution_names = (
+        _MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES - _MINIMAL_FLAG_CALLED_EVENT_PROPERTIES
+    )
+    messages: List[Dict[str, Any]] = []
+
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        messages.append(message)
+        return message
+
+    client = Client(
+        FAKE_TEST_API_KEY,
+        send=False,
+        before_send=before_send,
+        super_properties={name: "set-by-the-app" for name in attribution_names},
+    )
+    record = _record(
+        "condition_match", config_version=1, description=REASON_DESCRIPTION
+    )
+    try:
+        with _serving(_response(record, minimalFlagCalledEvents=True)):
+            client.get_feature_flag_result(FLAG, DISTINCT_ID)
+    finally:
+        client.shutdown()
+
+    [message] = messages
+    assert not attribution_names & set(message["properties"])
+
+
+# --- The exact events of a split ---------------------------------------------------------
+
+
+# The attribution of a split's $feature_flag_called.
+EXPECTED_ATTRIBUTION = {
+    "$feature_flag_config_version": 2,
+    "$feature_flag_reason_code": "experiment_split",
+    "$feature_flag_rule_id": RULE,
+    "$feature_flag_rule_type": "experiment",
+    "$feature_flag_variant_key": "annual-first",
+}
+EXPECTED_EXPOSURE = {
+    "$feature_flag": FLAG,
+    "$feature_flag_response": "annual",
+    "$feature_flag_variant_key": "annual-first",
+    "$feature_flag_rule_id": RULE,
+    "locally_evaluated": False,
+    "$feature_flag_id": 77,
+    "$feature_flag_version": 3,
+    "$feature_flag_request_id": REQUEST_ID,
+    "$feature_flag_evaluated_at": EVALUATED_AT,
+}
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_a_split_sends_both_events_with_exact_properties(path):
+    response = _response(_split(description="Assigned variant 'annual-first'"))
+
+    events = _read_events(path, response, groups={"company": "company-7"})
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE]
+    called, exposure = events
+    assert called.properties == {
+        "$feature_flag": FLAG,
+        "$feature_flag_response": "annual",
+        "locally_evaluated": False,
+        f"$feature/{FLAG}": "annual",
+        "$feature_flag_request_id": REQUEST_ID,
+        "$feature_flag_evaluated_at": EVALUATED_AT,
+        # The reason code replaces the record's reason description.
+        "$feature_flag_version": 3,
+        "$feature_flag_id": 77,
+        "$feature_flag_has_experiment": True,
+        **EXPECTED_ATTRIBUTION,
+    }
+    assert exposure.properties == EXPECTED_EXPOSURE
+    assert exposure.distinct_id == called.distinct_id == DISTINCT_ID
+    assert exposure.groups == called.groups == {"company": "company-7"}
+    assert exposure.property_allowlist is None
+
+
+async def test_async_split_sends_both_events_with_exact_properties():
+    async def read(client: Any) -> None:
+        snapshot = await client.evaluate_flags(
+            DISTINCT_ID, groups={"company": 7}, disable_geoip=True
+        )
+        snapshot.get_flag(FLAG)
+
+    response = _response(_split(description="Assigned variant 'annual-first'"))
+    events = await _read_async_events([response], [read])
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE]
+    called, exposure = events
+    assert exposure.properties == EXPECTED_EXPOSURE
+    assert _attribution(called.properties) == EXPECTED_ATTRIBUTION
+    assert "$feature_flag_reason" not in called.properties
+    # The async client sends group keys as strings.
+    assert exposure.groups == called.groups == {"company": "7"}
+    assert exposure.distinct_id == called.distinct_id == DISTINCT_ID
+
+
+def test_the_pair_shares_capture_identity_but_not_its_uuid():
+    messages: List[Dict[str, Any]] = []
+
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        messages.append(message)
+        return message
+
+    client = Client(FAKE_TEST_API_KEY, send=False, before_send=before_send)
+    try:
+        with _serving(_response(_split())):
+            snapshot = client.evaluate_flags(
+                DISTINCT_ID, groups={"company": "company-7"}, disable_geoip=True
+            )
+            assert snapshot.get_flag(FLAG) == "annual"
+    finally:
+        client.shutdown()
+
+    called, exposure = messages
+    assert (called["event"], exposure["event"]) == (FLAG_CALLED, EXPOSURE)
+    assert called["uuid"] and exposure["uuid"] and called["uuid"] != exposure["uuid"]
+    assert exposure["distinct_id"] == called["distinct_id"] == DISTINCT_ID
+    for name in ("$groups", "$lib", "$lib_version", "$geoip_disable"):
+        assert exposure["properties"][name] == called["properties"][name], name
+    assert exposure["properties"]["$groups"] == {"company": "company-7"}
+
+
+@pytest.mark.parametrize("path", SNAPSHOT_READS)
+def test_an_assignment_is_reported_whatever_the_read_returns(path):
+    # An experiment arm whose value is false still assigned the visitor to that arm.
+    response = _response(_split(value=False, variant_key="no-banner"))
+
+    events = _read_events(path, response)
+
+    [exposure] = _named(events, EXPOSURE)
+    assert exposure.properties["$feature_flag_response"] is False
+    assert exposure.properties["$feature_flag_variant_key"] == "no-banner"
+
+
+# --- What sends no exposure ------------------------------------------------------------
+
+
+@pytest.mark.parametrize("path", SINGLE_FLAG_READS)
+def test_opting_out_of_flag_events_suppresses_both(client, path):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording, warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        getattr(client, path)(FLAG, DISTINCT_ID, send_feature_flag_events=False)
+
+    assert events == []
+
+
+def test_a_payload_read_sends_no_flag_events(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording, warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        client.get_feature_flag_payload(FLAG, DISTINCT_ID)
+        snapshot = client.evaluate_flags(DISTINCT_ID)
+        snapshot.get_flag_payload(FLAG)
+
+    assert events == []
+
+
+def test_a_payload_read_that_sends_flag_events_also_sends_the_exposure(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording, warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        client.get_feature_flag_payload(
+            FLAG, DISTINCT_ID, send_feature_flag_events=True
+        )
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE]
+
+
+MATCH_VALUE_CASES = [
+    ("another value", _split(value="annual"), "monthly"),
+    ("the record's own value", _split(value="annual"), "annual"),
+    # Object and number arms both read as True, so equal values prove nothing about
+    # where a value came from.
+    ("an object arm", _split(value={"layout": "grid"}), True),
+    ("a number arm", _split(value=12.5), True),
+]
+
+
+@pytest.mark.parametrize("later_read", list(SYNC_READS))
+@pytest.mark.parametrize(
+    "record, match_value",
+    [case[1:] for case in MATCH_VALUE_CASES],
+    ids=[case[0] for case in MATCH_VALUE_CASES],
+)
+def test_a_payload_lookup_for_a_match_value_sends_no_exposure(
+    client, record, match_value, later_read
+):
+    # The lookup reports the caller's match_value, not the record's value, so it
+    # sends no exposure, whatever the value. A later read of the record does.
+    recording, events = _record_events(client)
+    with _serving(_response(record)), recording, warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        client.get_feature_flag_payload(
+            FLAG, DISTINCT_ID, match_value=match_value, send_feature_flag_events=True
+        )
+        [called] = events
+        assert called.name == FLAG_CALLED
+        assert called.properties["$feature_flag_response"] == match_value
+        # The record did not supply that value, so the call does not carry the
+        # record's attribution.
+        assert _attribution(called.properties) == {}
+
+        _read(client, later_read)
+
+    [exposure] = _named(events, EXPOSURE)
+    assert exposure.properties["$feature_flag_variant_key"] == "annual-first"
+
+
+def test_a_stale_cached_value_sends_no_exposure(client):
+    # The record arrived, but caching it failed, so the read reports the stale cached
+    # value instead. That value did not come from the record, even though it is equal.
+    cache = mock.Mock()
+    cache._set_cached_remote_flag.side_effect = RuntimeError("cache unavailable")
+    cache.get_stale_cached_flag.return_value = FeatureFlagResult(
+        key=FLAG, enabled=True, variant="annual", payload=None, reason=None
+    )
+    client.flag_cache = cache
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        result = client.get_feature_flag_result(FLAG, DISTINCT_ID)
+
+    assert result is not None and result.get_value() == "annual"
+    cache.get_stale_cached_flag.assert_called_once()
+    [called] = events
+    assert called.name == FLAG_CALLED
+    # The stale value is not attributed to the record's rule or variant.
+    assert _attribution(called.properties) == {}
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_a_locally_evaluated_flag_is_unchanged(path):
+    client = Client(FAKE_TEST_API_KEY, send=False, secret_key="secret-key")
+    client.feature_flags = [
+        {
+            "id": 9,
+            "name": "Pricing page",
+            "key": FLAG,
+            "active": True,
+            "filters": {
+                "groups": [{"properties": [], "rollout_percentage": 100}],
+                "multivariate": {
+                    "variants": [{"key": "annual", "rollout_percentage": 100}]
+                },
+            },
+        }
+    ]
+    recording, events = _record_events(client)
+    try:
+        with _serving(_response(_split())) as remote, recording:
+            _read(client, path)
+    finally:
+        client.shutdown()
+
+    assert remote.call_count == 0
+    [called] = events
+    assert called.name == FLAG_CALLED
+    assert called.properties["locally_evaluated"] is True
+    assert _attribution(called.properties) == {}
+
+
+def test_an_empty_snapshot_sends_nothing(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        snapshot = client.evaluate_flags()
+        snapshot.get_flag(FLAG)
+        snapshot.is_enabled(FLAG)
+
+    assert events == []
+
+
+def test_a_failed_exposure_capture_does_not_change_the_read():
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        if message["event"] == EXPOSURE:
+            raise ValueError("rejected")
+        return message
+
+    client = Client(FAKE_TEST_API_KEY, send=False, before_send=before_send)
+    try:
+        with _serving(_response(_split())), warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            assert client.get_feature_flag(FLAG, DISTINCT_ID) == "annual"
+            assert client.evaluate_flags(DISTINCT_ID).get_flag(FLAG) == "annual"
+    finally:
+        client.shutdown()
+
+
+# --- Dedupe ------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "first, second",
+    [
+        ("get_feature_flag", "get_feature_flag"),
+        ("snapshot.get_flag", "snapshot.is_enabled"),
+        ("feature_enabled", "snapshot.get_flag"),
+        ("snapshot.get_flag", "get_feature_flag_result"),
+    ],
+)
+def test_a_repeated_read_sends_nothing_new(client, first, second):
+    # The second evaluation has a new request ID and time, which neither event's
+    # dedupe reads.
+    later = _response(
+        _split(), request_id=OTHER_REQUEST_ID, evaluated_at=EVALUATED_AT + 1
+    )
+    recording, events = _record_events(client)
+    with _serving(_response(_split()), later), recording:
+        _read(client, first)
+        _read(client, second)
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE]
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_equal_valued_arms_are_each_reported(path):
+    # An A/A experiment: both arms return the same value.
+    events = _read_events(
+        path,
+        _response(_split(value=True, variant_key="control")),
+        _response(_split(value=True, variant_key="test")),
+        reads=2,
+    )
+
+    exposures = _named(events, EXPOSURE)
+    assert [e.properties["$feature_flag_variant_key"] for e in exposures] == [
+        "control",
+        "test",
+    ]
+    assert len(_named(events, FLAG_CALLED)) == 2
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_a_later_experiment_on_the_flag_is_reported_again(path):
+    events = _read_events(
+        path,
+        _response(_split(rule_id=RULE)),
+        _response(_split(rule_id=OTHER_RULE)),
+        reads=2,
+    )
+
+    exposures = _named(events, EXPOSURE)
+    assert [e.properties["$feature_flag_rule_id"] for e in exposures] == [
+        RULE,
+        OTHER_RULE,
+    ]
+    assert len(_named(events, FLAG_CALLED)) == 2
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_the_exposure_dedupe_leaves_out_the_value(path):
+    # The arm's value changed, but the visitor is still in the same arm.
+    events = _read_events(
+        path,
+        _response(_split(value="annual")),
+        _response(_split(value="annual-v2")),
+        reads=2,
+    )
+
+    assert len(_named(events, FLAG_CALLED)) == 2
+    assert len(_named(events, EXPOSURE)) == 1
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_a_holdout_and_a_split_of_one_rule_are_both_reported(path):
+    holdout = _record(
+        "holdout", False, rule_type="experiment", rule_id=RULE, has_experiment=True
+    )
+    events = _read_events(
+        path, _response(holdout), _response(_split(value=False)), reads=2
+    )
+
+    called = _named(events, FLAG_CALLED)
+    assert [e.properties["$feature_flag_reason_code"] for e in called] == [
+        "holdout",
+        "experiment_split",
+    ]
+    assert len(_named(events, EXPOSURE)) == 1
+
+
+def test_groups_are_part_of_the_exposure_identity(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        _read(client, "snapshot.get_flag", groups={"company": "a", "team": "b"})
+        _read(client, "get_feature_flag", groups={"team": "b", "company": "a"})
+        _read(client, "snapshot.get_flag", groups={"company": "c"})
+
+    exposures = _named(events, EXPOSURE)
+    assert [e.groups for e in exposures] == [
+        {"company": "a", "team": "b"},
+        {"company": "c"},
+    ]
+
+
+def test_the_exposure_dedupe_normalizes_the_distinct_id(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        _read(client, "get_feature_flag_result", distinct_id=42)
+        _read(client, "snapshot.get_flag", distinct_id="42")
+
+    assert len(_named(events, EXPOSURE)) == 1
+
+
+def test_a_reported_call_never_suppresses_its_exposure(client):
+    # The two events dedupe apart. When only the exposure key is gone, as after an
+    # eviction, the next read sends the exposure again, although its call is a
+    # duplicate.
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        _read(client, "get_feature_flag")
+        client._experiment_exposures_reported.clear()
+        _read(client, "get_feature_flag")
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE, EXPOSURE]
+
+
+async def test_async_a_reported_call_never_suppresses_its_exposure():
+    async def read(client: Any) -> None:
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        snapshot.get_flag(FLAG)
+        client._experiment_exposures_reported.clear()
+        snapshot.get_flag(FLAG)
+
+    events = await _read_async_events([_response(_split())], [read])
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE, EXPOSURE]
+
+
+def test_a_read_whose_value_the_record_did_not_supply_is_reported_as_before(client):
+    # Such a read sends the config version 1 call and no exposure, and takes neither
+    # config version 2 dedupe key: a later read of the record sends both its events.
+    with _serving(_response(_split(description="Assigned variant annual-first"))):
+        details = client.evaluate_flags(DISTINCT_ID)._flags[FLAG].details
+    recording, events = _record_events(client)
+    with recording:
+        for value_from_details in (False, True):
+            client._capture_feature_flag_called_if_needed(
+                distinct_id=DISTINCT_ID,
+                key=FLAG,
+                response="annual",
+                properties={
+                    "$feature_flag": FLAG,
+                    "$feature_flag_response": "annual",
+                    "$feature_flag_reason": "Assigned variant annual-first",
+                },
+                details=details,
+                value_from_details=value_from_details,
+            )
+
+    assert [event.name for event in events] == [FLAG_CALLED, FLAG_CALLED, EXPOSURE]
+    as_before, attributed = _named(events, FLAG_CALLED)
+    assert _attribution(as_before.properties) == {}
+    assert as_before.properties["$feature_flag_reason"] == (
+        "Assigned variant annual-first"
+    )
+    assert _attribution(attributed.properties) == EXPECTED_ATTRIBUTION
+    assert "$feature_flag_reason" not in attributed.properties
+
+
+async def test_async_snapshots_dedupe_both_events():
+    async def read(client: Any) -> None:
+        snapshot = await client.evaluate_flags(DISTINCT_ID)
+        snapshot.get_flag(FLAG)
+        snapshot.is_enabled(FLAG)
+        snapshot.only([FLAG]).get_flag(FLAG)
+
+    events = await _read_async_events(
+        [
+            _response(_split(variant_key="control", value=True)),
+            _response(_split(variant_key="control", value=True)),
+            _response(_split(variant_key="test", value=True)),
+        ],
+        [read, read, read],
+    )
+
+    assert [e.properties["$feature_flag_variant_key"] for e in events] == [
+        "control",
+        "control",
+        "test",
+        "test",
+    ]
+    assert [e.name for e in events] == [FLAG_CALLED, EXPOSURE] * 2
+
+
+def test_the_v1_dedupe_key_is_unchanged(client):
+    with _serving(_build(READERS, {"template": "v1"})):
+        _read(client, "get_feature_flag", "garden-layout")
+
+    assert client.distinct_ids_feature_flags_reported[DISTINCT_ID] == {
+        ("garden-layout", "compact", ())
+    }
+    assert len(client._experiment_exposures_reported) == 0
+
+
+def test_shutdown_clears_the_exposure_dedupe():
+    client = Client(FAKE_TEST_API_KEY, send=False)
+    with _serving(_response(_split())):
+        _read(client, "snapshot.get_flag")
+    assert len(client._experiment_exposures_reported) == 1
+
+    client.shutdown()
+
+    assert len(client._experiment_exposures_reported) == 0
+
+
+async def test_async_shutdown_clears_the_exposure_dedupe():
+    with mock.patch(
+        "posthog.async_client._async_flags",
+        new=mock.AsyncMock(return_value=_response(_split())),
+    ):
+        client = AsyncPosthog("project-key", send=False)
+        (await client.evaluate_flags(DISTINCT_ID)).get_flag(FLAG)
+        assert len(client._experiment_exposures_reported) == 1
+        await client.shutdown()
+
+    assert len(client._experiment_exposures_reported) == 0
+
+
+# --- Minimal events -------------------------------------------------------------------
+
+
+def test_minimal_flag_called_events_keep_the_attribution():
+    messages: List[Dict[str, Any]] = []
+
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        messages.append(message)
+        return message
+
+    client = Client(
+        FAKE_TEST_API_KEY,
+        send=False,
+        before_send=before_send,
+        super_properties={"plan": "team"},
+    )
+    # A split of an experiment rule no experiment links to: the flag reports no
+    # experiment, so its $feature_flag_called is minimal.
+    response = _response(_split(has_experiment=False), minimalFlagCalledEvents=True)
+    try:
+        with _serving(response):
+            client.evaluate_flags(DISTINCT_ID).get_flag(FLAG)
+    finally:
+        client.shutdown()
+
+    called, exposure = messages
+    assert set(called["properties"]) <= _MINIMAL_V2_FLAG_CALLED_EVENT_PROPERTIES
+    assert "plan" not in called["properties"]
+    assert _attribution(called["properties"]) == EXPECTED_ATTRIBUTION
+    # The exposure is a full event.
+    assert exposure["event"] == EXPOSURE
+    assert exposure["properties"]["plan"] == "team"
+    assert _attribution(exposure["properties"]) == _attribution(EXPECTED_EXPOSURE)
+
+
+# --- Reason codes, rule IDs and variant keys ---------------------------------------------
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize("code", ["future_reason", None], ids=["unknown", "missing"])
+def test_an_unknown_or_missing_reason_code_still_reports_config_version_2(code, path):
+    record = _split()
+    if code is None:
+        del record["reason"]
+    else:
+        record["reason"]["code"] = code
+
+    events = _read_events(path, _response(record))
+
+    [called] = _named(events, FLAG_CALLED)
+    expected: Dict[str, Any] = {"$feature_flag_config_version": 2}
+    if code is not None:
+        expected["$feature_flag_reason_code"] = code
+    assert _attribution(called.properties) == expected
+    assert "$feature_flag_reason" not in called.properties
+    assert _named(events, EXPOSURE) == []
+    FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+NOT_A_UUID = ["rule-1", "", "7F3C2A108D4E4B6A9C215E0F1A2B3C4D", "{" + RULE + "}"]
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag_result", "snapshot.get_flag"])
+@pytest.mark.parametrize("rule_id", NOT_A_UUID)
+def test_a_rule_id_that_is_not_a_uuid_counts_as_missing(rule_id, path):
+    for record in (
+        _split(rule_id=rule_id),
+        _record("targeting_match", rule_type="targeted_release", rule_id=rule_id),
+    ):
+        events = _read_events(path, _response(record))
+
+        [called] = _named(events, FLAG_CALLED)
+        assert _attribution(called.properties) == {
+            "$feature_flag_config_version": 2,
+            "$feature_flag_reason_code": record["reason"]["code"],
+        }
+        assert _named(events, EXPOSURE) == []
+        FLAG_CALLED_SCHEMA.validate(_projection(FLAG_CALLED_SCHEMA, called.properties))
+
+
+def test_an_upper_case_uuid_rule_id_is_kept():
+    events = _read_events(
+        "get_feature_flag_result", _response(_split(rule_id=RULE.upper()))
+    )
+
+    [exposure] = _named(events, EXPOSURE)
+    assert exposure.properties["$feature_flag_rule_id"] == RULE.upper()
+
+
+@pytest.mark.parametrize("path", list(SYNC_READS))
+def test_an_empty_variant_key_is_a_complete_split(path):
+    events = _read_events(path, _response(_split(variant_key="")))
+
+    [called] = _named(events, FLAG_CALLED)
+    assert called.properties["$feature_flag_variant_key"] == ""
+    [exposure] = _named(events, EXPOSURE)
+    assert exposure.properties["$feature_flag_variant_key"] == ""
+    EXPOSURE_SCHEMA.validate(_projection(EXPOSURE_SCHEMA, exposure.properties))
+
+
+# --- Capture failures ----------------------------------------------------------------------
+
+
+def _dropping(event: str) -> Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]:
+    """A before_send hook that drops the first ``event`` and keeps everything else."""
+    dropped: List[str] = []
+
+    def before_send(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        if message["event"] == event and not dropped:
+            dropped.append(event)
+            return None
+        return message
+
+    return before_send
+
+
+def _failing_once(client: Client, event: str, failure: str) -> Any:
+    """Patch ``client.capture`` to fail for the first ``event``, then capture as usual.
+
+    ``failure`` is ``"raise"`` for a raising capture, or ``"unqueued"`` for a capture
+    that returns ``None`` without ``before_send`` dropping the event, as a full or
+    closed queue, opt-out or a disabled client does.
+    """
+    capture = client.capture
+    failed: List[str] = []
+
+    def maybe_fail(name: str, **kwargs: Any) -> Optional[str]:
+        if name == event and not failed:
+            failed.append(name)
+            if failure == "raise":
+                raise RuntimeError("capture failed")
+            return None
+        return capture(name, **kwargs)
+
+    return mock.patch.object(client, "capture", side_effect=maybe_fail)
+
+
+def _sent(client: Client, path: str, reads: int = 2) -> List[str]:
+    """The events that reached the queue over ``reads`` reads of a complete split."""
+    sent: List[str] = []
+    enqueue = client._enqueue
+
+    def record(msg: Dict[str, Any], *args: Any, **kwargs: Any) -> Optional[str]:
+        uuid = enqueue(msg, *args, **kwargs)
+        if uuid is not None:
+            sent.append(msg["event"])
+        return uuid
+
+    with (
+        _serving(_response(_split())),
+        mock.patch.object(client, "_enqueue", side_effect=record),
+    ):
+        for _ in range(reads):
+            assert _read(client, path) == "annual"
+    return sent
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag", "snapshot.get_flag"])
+@pytest.mark.parametrize("event", [FLAG_CALLED, EXPOSURE])
+def test_an_event_dropped_by_before_send_keeps_its_dedupe_key(event, path):
+    client = Client(FAKE_TEST_API_KEY, send=False, before_send=_dropping(event))
+    try:
+        sent = _sent(client, path)
+    finally:
+        client.shutdown()
+
+    # The application dropped the event, so the second read does not send it again.
+    # The other event of the first read is still sent, once.
+    assert sent == [EXPOSURE if event == FLAG_CALLED else FLAG_CALLED]
+
+
+async def test_async_an_event_dropped_by_before_send_keeps_its_dedupe_key():
+    seen: List[str] = []
+    batches: List[Any] = []
+
+    def before_send(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        seen.append(message["event"])
+        return None if message["event"] == EXPOSURE else message
+
+    async def batch_post(*args: Any, **kwargs: Any) -> None:
+        batches.append(kwargs["batch"])
+
+    with (
+        mock.patch(
+            "posthog.async_client._async_flags",
+            new=mock.AsyncMock(return_value=_response(_split())),
+        ),
+        mock.patch("posthog._async_consumer.async_batch_post", side_effect=batch_post),
+    ):
+        client = AsyncPosthog("project-key", before_send=before_send, flush_interval=30)
+        for _ in range(2):
+            snapshot = await client.evaluate_flags(DISTINCT_ID)
+            assert snapshot.get_flag(FLAG) == "annual"
+            await client.flush(timeout_seconds=1)
+        await client.shutdown()
+
+    # before_send saw each event once: the dropped exposure kept its key, so the
+    # second read sent neither event again.
+    assert seen == [FLAG_CALLED, EXPOSURE]
+    sent = [event["event"] for batch in batches for event in batch]
+    assert sent == [FLAG_CALLED]
+
+
+@pytest.mark.parametrize("path", ["get_feature_flag", "snapshot.get_flag"])
+@pytest.mark.parametrize("event", [FLAG_CALLED, EXPOSURE])
+@pytest.mark.parametrize("failure", ["raise", "unqueued"])
+def test_a_failed_capture_keeps_no_dedupe_key(failure, event, path, client):
+    with _failing_once(client, event, failure):
+        sent = _sent(client, path)
+
+    # The other event of the first read is still sent, and the failed one is sent
+    # by the second read, once.
+    assert sorted(sent) == sorted([FLAG_CALLED, EXPOSURE])
+
+
+def test_an_unqueued_config_version_1_call_is_deduped_as_before(client):
+    record = _record("condition_match", "annual", config_version=1)
+    calls: List[str] = []
+
+    def unqueued(name: str, **kwargs: Any) -> None:
+        calls.append(name)
+        return None
+
+    with (
+        _serving(_response(record)),
+        mock.patch.object(client, "capture", side_effect=unqueued),
+    ):
+        _read(client, "get_feature_flag")
+        _read(client, "get_feature_flag")
+
+    # Config version 1 dedupe is unchanged: the attempt takes the key.
+    assert calls == [FLAG_CALLED]
+
+
+class _Rendezvous:
+    """Holds each of the first two callers until the other one arrives.
+
+    When the dedupe check and the reservation are one step, the second read waits
+    for the first one to finish both, so the wait times out instead.
+    """
+
+    def __init__(self) -> None:
+        self._barrier = threading.Barrier(2, timeout=0.25)
+        self._lock = threading.Lock()
+        self.arrivals = 0
+
+    def __call__(self) -> None:
+        with self._lock:
+            self.arrivals += 1
+            arrival = self.arrivals
+        if arrival <= 2:
+            try:
+                self._barrier.wait()
+            except threading.BrokenBarrierError:
+                pass
+
+
+class _MeetingSet(set):
+    """A dedupe set: each membership check reads the set, then meets the other read."""
+
+    def __init__(self, meet: _Rendezvous) -> None:
+        super().__init__()
+        self._meet = meet
+
+    def __contains__(self, item: Any) -> bool:
+        found = super().__contains__(item)
+        self._meet()
+        return found
+
+
+class _MeetingDict(SizeLimitedDict):
+    """A dedupe map: each lookup reads the map, then meets the other read."""
+
+    def __init__(self, meet: _Rendezvous) -> None:
+        super().__init__(MAX_DICT_SIZE, set)
+        self._meet = meet
+
+    def get(self, key: Any, default: Any = None) -> Any:
+        found = super().get(key, default)
+        self._meet()
+        return found
+
+
+@pytest.mark.parametrize("event", [FLAG_CALLED, EXPOSURE])
+@pytest.mark.parametrize("distinct_id", ["seen", "new"])
+def test_concurrent_reads_of_one_outcome_send_each_event_once(
+    client, event, distinct_id
+):
+    # Two reads of one outcome both look up the dedupe key before either goes on.
+    # Unless the check and the reservation are one step, both find no key and both
+    # send the event. "new" also races on the distinct ID's first entry.
+    meet = _Rendezvous()
+    attribute = (
+        "distinct_ids_feature_flags_reported"
+        if event == FLAG_CALLED
+        else "_experiment_exposures_reported"
+    )
+    if distinct_id == "seen":
+        getattr(client, attribute)[DISTINCT_ID] = _MeetingSet(meet)
+    else:
+        setattr(client, attribute, _MeetingDict(meet))
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        reads = [
+            threading.Thread(target=_read, args=(client, "get_feature_flag"))
+            for _ in range(2)
+        ]
+        for read in reads:
+            read.start()
+        for read in reads:
+            read.join(5)
+
+    assert meet.arrivals == 2
+    sent = [e.name for e in events if e.uuid is not None]
+    assert sorted(sent) == sorted([FLAG_CALLED, EXPOSURE])
+
+
+@pytest.mark.parametrize("delivered", [True, False], ids=["delivered", "failed"])
+def test_a_read_during_a_sync_mode_send_does_not_send_it_again(delivered):
+    # The second read runs while the first read's exposure is on the wire. It sends
+    # neither event. A send that fails releases the key, so a third read sends the
+    # exposure.
+    client = Client(FAKE_TEST_API_KEY, sync_mode=True, capture_mode="v0")
+    sending = threading.Event()
+    finish = threading.Event()
+    posted: List[str] = []
+
+    def batch_post(*args: Any, batch: List[Dict[str, Any]], **kwargs: Any) -> None:
+        [message] = batch
+        posted.append(message["event"])
+        if message["event"] == EXPOSURE and posted.count(EXPOSURE) == 1:
+            sending.set()
+            finish.wait(5)
+            if not delivered:
+                raise RuntimeError("connection reset")
+
+    try:
+        with (
+            _serving(_response(_split())),
+            mock.patch("posthog.client.batch_post", side_effect=batch_post),
+        ):
+            first = threading.Thread(target=_read, args=(client, "get_feature_flag"))
+            first.start()
+            assert sending.wait(5)
+            assert _read(client, "get_feature_flag") == "annual"
+            finish.set()
+            first.join(5)
+            assert _read(client, "get_feature_flag") == "annual"
+    finally:
+        finish.set()
+        client.shutdown()
+
+    assert posted == [FLAG_CALLED, EXPOSURE] + ([] if delivered else [EXPOSURE])
+
+
+def test_a_forked_child_replaces_the_dedupe_lock(client):
+    # A parent thread can hold the lock when the process forks. The child replaces
+    # it, so its reads do not wait for a thread the child does not have.
+    with posthog_client._flag_event_keys_lock:
+        posthog_client._reinit_flag_event_keys_lock_after_fork()
+        events = _read_events("get_feature_flag", _response(_split()), client=client)
+
+    assert [event.name for event in events] == [FLAG_CALLED, EXPOSURE]
+
+
+def test_a_flags_reload_does_not_repeat_an_exposure(client):
+    recording, events = _record_events(client)
+    with _serving(_response(_split())), recording:
+        _read(client, "get_feature_flag")
+        client._update_flag_state(
+            {"flags": [], "group_type_mapping": {}, "cohorts": {}}
+        )
+        _read(client, "get_feature_flag")
+        client.evaluate_flags(DISTINCT_ID).get_flag(FLAG)
+
+    assert len(_named(events, EXPOSURE)) == 1
+
+
+# --- Super properties ------------------------------------------------------------------------
+
+SPOOFED_SUPER_PROPERTIES = {
+    "$feature_flag_config_version": 7,
+    "$feature_flag_reason_code": "spoofed",
+    "$feature_flag_rule_type": "spoofed",
+    "$feature_flag_rule_id": OTHER_RULE,
+    "$feature_flag_variant_key": "spoofed",
+    "$feature_flag_reason": "spoofed",
+    "$feature_flag_forced_variant": True,
+    "$feature_flag_experiment_id": 301,
+    "$experiment_exposure_source": "spoofed",
+    # The flag identity of the read.
+    "$feature_flag": "spoofed",
+    "$feature_flag_response": "spoofed",
+    "locally_evaluated": True,
+}
+
+# What both events of a split read report about the read itself.
+EXPECTED_FLAG_IDENTITY = {
+    "$feature_flag": FLAG,
+    "$feature_flag_response": "annual",
+    "locally_evaluated": False,
+}
+
+
+def _flag_identity(properties: Mapping[str, Any]) -> Dict[str, Any]:
+    return {
+        name: properties[name] for name in EXPECTED_FLAG_IDENTITY if name in properties
+    }
+
+
+def _messages_with_super_properties(record: Dict[str, Any]) -> List[Dict[str, Any]]:
+    messages: List[Dict[str, Any]] = []
+
+    def before_send(message: Dict[str, Any]) -> Dict[str, Any]:
+        messages.append(copy.deepcopy(message))
+        return message
+
+    client = Client(
+        FAKE_TEST_API_KEY,
+        send=False,
+        before_send=before_send,
+        super_properties=dict(SPOOFED_SUPER_PROPERTIES),
+    )
+    try:
+        with _serving(_response(record)):
+            _read(client, "get_feature_flag")
+    finally:
+        client.shutdown()
+    return messages
+
+
+def test_super_properties_cannot_change_config_version_2_attribution():
+    messages = _messages_with_super_properties(_split())
+
+    [called] = [m for m in messages if m["event"] == FLAG_CALLED]
+    assert _attribution(called["properties"]) == EXPECTED_ATTRIBUTION
+    for name in (
+        "$feature_flag_reason",
+        "$feature_flag_forced_variant",
+        "$feature_flag_experiment_id",
+    ):
+        assert name not in called["properties"], name
+    [exposure] = [m for m in messages if m["event"] == EXPOSURE]
+    assert _attribution(exposure["properties"]) == _attribution(EXPECTED_EXPOSURE)
+    assert not set(EXPOSURE_LEAVES_OUT) & set(exposure["properties"])
+    for name in ("$feature_flag_experiment_id", "$feature_flag_forced_variant"):
+        assert name not in exposure["properties"], name
+    EXPOSURE_SCHEMA.validate(_projection(EXPOSURE_SCHEMA, exposure["properties"]))
+
+
+def test_super_properties_cannot_change_the_flag_identity_of_config_version_2_events():
+    messages = _messages_with_super_properties(_split())
+
+    # Both events report the same flag, response and evaluation source.
+    [called] = [m for m in messages if m["event"] == FLAG_CALLED]
+    assert _flag_identity(called["properties"]) == EXPECTED_FLAG_IDENTITY
+    [exposure] = [m for m in messages if m["event"] == EXPOSURE]
+    assert _flag_identity(exposure["properties"]) == EXPECTED_FLAG_IDENTITY
+
+
+def test_super_properties_cannot_add_rule_fields_a_config_version_2_call_omits():
+    messages = _messages_with_super_properties(_record("no_rule_match", False))
+
+    [called] = messages
+    assert _attribution(called["properties"]) == {
+        "$feature_flag_config_version": 2,
+        "$feature_flag_reason_code": "no_rule_match",
+    }
+
+
+def test_super_properties_still_apply_to_config_version_1_calls():
+    record = _record("condition_match", "annual", config_version=1)
+    [called] = _messages_with_super_properties(record)
+
+    for name, value in SPOOFED_SUPER_PROPERTIES.items():
+        assert called["properties"][name] == value, name
+
+
+async def test_async_super_properties_cannot_change_config_version_2_attribution():
+    messages: List[Dict[str, Any]] = []
+    with mock.patch(
+        "posthog.async_client._async_flags",
+        new=mock.AsyncMock(return_value=_response(_split())),
+    ):
+        client = AsyncPosthog(
+            "project-key",
+            send=False,
+            super_properties=dict(SPOOFED_SUPER_PROPERTIES),
+        )
+        prepare = client._prepare_event
+
+        def record(*args: Any, **kwargs: Any) -> Any:
+            prepared, uuid = prepare(*args, **kwargs)
+            messages.append(copy.deepcopy(prepared))
+            return prepared, uuid
+
+        with mock.patch.object(client, "_prepare_event", side_effect=record):
+            snapshot = await client.evaluate_flags(DISTINCT_ID)
+            snapshot.get_flag(FLAG)
+        await client.shutdown()
+
+    [called] = [m for m in messages if m["event"] == FLAG_CALLED]
+    assert _attribution(called["properties"]) == EXPECTED_ATTRIBUTION
+    assert _flag_identity(called["properties"]) == EXPECTED_FLAG_IDENTITY
+    assert "$feature_flag_reason" not in called["properties"]
+    [exposure] = [m for m in messages if m["event"] == EXPOSURE]
+    assert _attribution(exposure["properties"]) == _attribution(EXPECTED_EXPOSURE)
+    assert _flag_identity(exposure["properties"]) == EXPECTED_FLAG_IDENTITY
+    assert not set(EXPOSURE_LEAVES_OUT) & set(exposure["properties"])
diff --git a/posthog/test/test_flags_released_behaviour.py b/posthog/test/test_flags_released_behaviour.py
index 3141dd891..7f5dd12b9 100644
--- a/posthog/test/test_flags_released_behaviour.py
+++ b/posthog/test/test_flags_released_behaviour.py
@@ -30,7 +30,7 @@ def results(request: Any) -> Dict[str, Any]:
     return scenarios.run_all(request.param)
 
 
-def test_every_legacy_getter_and_event_matches_7_82_1(results):
+def test_every_legacy_getter_and_event_matches_7_82_1(request, results):
     expected = copy.deepcopy(RELEASED["getters"])
     # A record without a flag ID or version reads them as absent (None), where 7.82.1
     # read 0. Events already left out both, so only the parsed record differs.
@@ -58,6 +58,21 @@ def test_every_legacy_getter_and_event_matches_7_82_1(results):
     for properties in failed_events:
         assert properties.pop("$feature_flag_payload") == {"columns": 2}
 
+    if request.node.callspec.params["results"] == "v4":
+        # A $feature_flag_called for a config version 2 record carries its config
+        # version and reason code in place of the reason text. Only the v4 shape says
+        # a record is config version 2; config version 1 events are unchanged.
+        for name, properties in expected["events"]:
+            if name == "$feature_flag_called" and properties[
+                "$feature_flag"
+            ].startswith("v2-"):
+                assert (
+                    properties.pop("$feature_flag_reason")
+                    == scenarios.MATCHED["description"]
+                )
+                properties["$feature_flag_config_version"] = 2
+                properties["$feature_flag_reason_code"] = scenarios.MATCHED["code"]
+
     assert results["getters"] == expected
 
 
diff --git a/posthog/test/test_flags_v4_response.py b/posthog/test/test_flags_v4_response.py
index 30e22a7fb..352c793aa 100644
--- a/posthog/test/test_flags_v4_response.py
+++ b/posthog/test/test_flags_v4_response.py
@@ -1,8 +1,8 @@
-"""Reading the ``/flags?v=4`` response, checked against the released wire contract.
+"""Reading the ``/flags?v=4`` response, checked against the harness wire contract.
 
-The files in ``fixtures/feature_flag_rules_v2`` are copied unchanged from a released
-``PostHog/posthog-sdk-test-harness`` contract. ``SOURCE.json`` records the release and
-the digest of each file.
+The files in ``fixtures/feature_flag_rules_v2`` are copied unchanged from a
+``PostHog/posthog-sdk-test-harness`` contract. ``SOURCE.json`` records the revision,
+its release and the digest of each file.
 """
 
 from __future__ import annotations
@@ -83,8 +83,9 @@ def _evaluate(client: Client, response: Dict[str, Any]) -> FeatureFlagEvaluation
 
 def test_vendored_fixtures_match_the_recorded_release_digests():
     source = _load("SOURCE.json")
-    assert source["release"] == "1.22.0"
-    assert source["contract_version"] == "7.0.0"
+    assert source["release"] == "1.30.0"
+    assert source["revision"] == "6414114501396d96aadf2412fdd8054a03076782"
+    assert source["contract_version"] == "10.0.0"
     for name, entry in source["files"].items():
         digest = hashlib.sha256((FIXTURES / name).read_bytes()).hexdigest()
         assert digest == entry["sha256"], name
@@ -1112,11 +1113,27 @@ def _parity_response(shape: str) -> Dict[str, Any]:
     }
 
 
+# A config version 2 record adds these to its flag events, and leaves out
+# $feature_flag_reason. A v2-shaped response has no config version 2 records, so they
+# are left out of the comparison of the v2-* flags and checked in
+# test_experiment_exposure.py.
+_CONFIG_VERSION_2_EVENT_PROPERTIES = {
+    "$feature_flag_config_version",
+    "$feature_flag_reason_code",
+    "$feature_flag_rule_id",
+    "$feature_flag_rule_type",
+    "$feature_flag_variant_key",
+}
+
+
 def _flag_event_properties(message: Dict[str, Any]) -> Dict[str, Any]:
+    left_out = set(_CONFIG_VERSION_2_EVENT_PROPERTIES)
+    if str(message["properties"].get("$feature_flag", "")).startswith("v2-"):
+        left_out.add("$feature_flag_reason")
     return {
         key: value
         for key, value in message["properties"].items()
-        if key.startswith("$feature")
+        if (key.startswith("$feature") and key not in left_out)
         or key in ("$active_feature_flags", "locally_evaluated")
     }
 
@@ -1132,7 +1149,8 @@ def response(*args: Any, **kwargs: Any) -> Dict[str, Any]:
 
     def enqueue(message: Dict[str, Any], *args: Any, **kwargs: Any) -> Optional[str]:
         events.append((message["event"], _flag_event_properties(message)))
-        return None
+        # Accept the event, as the real queue does, by returning an event UUID.
+        return "70000000-0000-4000-8000-000000000000"
 
     try:
         with (

From 8c9867cc159c03149ee00c05e4818334fea9f218 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 11 Nov 2026 08:39:23 +0000
Subject: [PATCH 240/245] chore: Release v7.87.0 [skip ci]

---
 .sampo/changesets/experiment-exposure.md | 5 -----
 openfeature-provider/CHANGELOG.md        | 6 ++++++
 openfeature-provider/pyproject.toml      | 2 +-
 posthog/CHANGELOG.md                     | 6 ++++++
 posthog/version.py                       | 2 +-
 pyproject.toml                           | 2 +-
 uv.lock                                  | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/experiment-exposure.md

diff --git a/.sampo/changesets/experiment-exposure.md b/.sampo/changesets/experiment-exposure.md
deleted file mode 100644
index 66e9d70c1..000000000
--- a/.sampo/changesets/experiment-exposure.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: minor
----
-
-Send `$experiment_exposure` for config version 2 experiment splits, and send the reason code and rule attribution on `$feature_flag_called` for config version 2 flags in place of `$feature_flag_reason`.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index 03831c80a..cd71a29c9 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.157 — 2026-11-11
+
+### Patch changes
+
+- Updated dependencies: posthog@7.87.0
+
 ## 0.1.156 — 2026-11-10
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index d874d5eb2..c07e83989 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.156"
+version = "0.1.157"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index ec254cb54..04902a954 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.87.0 — 2026-11-11
+
+### Minor changes
+
+- [5febfd9b](https://github.com/posthog/posthog-python/commit/5febfd9b13d9d78e2f0cd253356badabf4e51c65) Send `$experiment_exposure` for config version 2 experiment splits, and send the reason code and rule attribution on `$feature_flag_called` for config version 2 flags in place of `$feature_flag_reason`. — Thanks @andehen!
+
 ## 7.86.6 — 2026-11-10
 
 ### Patch changes
diff --git a/posthog/version.py b/posthog/version.py
index 5ded7edab..1a38d7357 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.86.6"
+VERSION = "7.87.0"
diff --git a/pyproject.toml b/pyproject.toml
index aaefb1b5f..683d979bb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.86.6"
+version = "7.87.0"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index c92385a2d..229869463 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2723,7 +2723,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.156"
+version = "0.1.157"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3280,7 +3280,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.86.6"
+version = "7.87.0"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From b182023e33bf3ef6bd9c388c80cd96eff936a9de Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 11 Nov 2026 08:39:33 +0000
Subject: [PATCH 241/245] Update generated references

---
 references/posthog-python-7.md         | 10 ++++++++++
 references/posthog-python-reference.md | 10 ++++++++++
 2 files changed, 20 insertions(+)

diff --git a/references/posthog-python-7.md b/references/posthog-python-7.md
index ab200d47e..bfa813789 100644
--- a/references/posthog-python-7.md
+++ b/references/posthog-python-7.md
@@ -595,6 +595,9 @@ get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Map
 Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
 depending on whether local evaluation is enabled and the flag can be locally evaluated.
 This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+When the flag was evaluated remotely and its config version 2 record is a complete experiment
+split (an experiment rule with a rule ID and a variant key), it also captures the
+`$experiment_exposure` event, once per distinct ID, groups, flag, rule and variant.
 
 **Examples:**
 
@@ -3019,6 +3022,13 @@ To narrow the set of flags that get attached to a captured event, use the in-mem
 helpers `only` and `only_accessed`. To narrow the set of flags requested
 from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
 
+Reading a flag sends `$feature_flag_called`, deduplicated as `is_enabled`
+describes. When the flag was evaluated remotely and its config version 2 record is
+a complete experiment split (an experiment rule with a rule ID and a variant key),
+the read also sends `$experiment_exposure`. The SDK sends one exposure per
+distinct ID, groups, flag, rule and variant. `send_feature_flag_events=False`
+suppresses both events.
+
 **Functions:**
 
 Name | Description
diff --git a/references/posthog-python-reference.md b/references/posthog-python-reference.md
index 8011d5817..fa798a96c 100644
--- a/references/posthog-python-reference.md
+++ b/references/posthog-python-reference.md
@@ -595,6 +595,9 @@ get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Map
 Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
 depending on whether local evaluation is enabled and the flag can be locally evaluated.
 This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+When the flag was evaluated remotely and its config version 2 record is a complete experiment
+split (an experiment rule with a rule ID and a variant key), it also captures the
+`$experiment_exposure` event, once per distinct ID, groups, flag, rule and variant.
 
 **Examples:**
 
@@ -3019,6 +3022,13 @@ To narrow the set of flags that get attached to a captured event, use the in-mem
 helpers `only` and `only_accessed`. To narrow the set of flags requested
 from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
 
+Reading a flag sends `$feature_flag_called`, deduplicated as `is_enabled`
+describes. When the flag was evaluated remotely and its config version 2 record is
+a complete experiment split (an experiment rule with a rule ID and a variant key),
+the read also sends `$experiment_exposure`. The SDK sends one exposure per
+distinct ID, groups, flag, rule and variant. `send_feature_flag_events=False`
+suppresses both events.
+
 **Functions:**
 
 Name | Description

From c28716c20d75b4ca5dfe2aaedd4f14ff7086a769 Mon Sep 17 00:00:00 2001
From: Ioannis J <yiannis@posthog.com>
Date: Wed, 11 Nov 2026 20:05:21 +0200
Subject: [PATCH 242/245] fix(flags): keep IPv6 brackets in Redis fallback
 cache URLs (#1228)

---
 .sampo/changesets/gentle-harbor-ilmatar.md | 5 +++++
 posthog/client.py                          | 7 ++++---
 posthog/test/test_client.py                | 9 +++++++++
 3 files changed, 18 insertions(+), 3 deletions(-)
 create mode 100644 .sampo/changesets/gentle-harbor-ilmatar.md

diff --git a/.sampo/changesets/gentle-harbor-ilmatar.md b/.sampo/changesets/gentle-harbor-ilmatar.md
new file mode 100644
index 000000000..4c9ee83ec
--- /dev/null
+++ b/.sampo/changesets/gentle-harbor-ilmatar.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: patch
+---
+
+Fix `flag_fallback_cache_url` for Redis URLs with an IPv6 host: the brackets are kept, so the Redis flag cache is no longer disabled.
diff --git a/posthog/client.py b/posthog/client.py
index 5c075da73..35380d979 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -5679,9 +5679,10 @@ def _initialize_flag_cache(self, cache_url):
                     redis_url = f"{parsed.scheme}://"
                     if parsed.username or parsed.password:
                         redis_url += f"{parsed.username or ''}:{parsed.password or ''}@"
-                    redis_url += (
-                        f"{parsed.hostname or 'localhost'}:{parsed.port or 6379}"
-                    )
+                    host = parsed.hostname or "localhost"
+                    if ":" in host:
+                        host = f"[{host}]"
+                    redis_url += f"{host}:{parsed.port or 6379}"
                     if parsed.path:
                         redis_url += parsed.path
 
diff --git a/posthog/test/test_client.py b/posthog/test/test_client.py
index 2a1923028..aee8342ab 100644
--- a/posthog/test/test_client.py
+++ b/posthog/test/test_client.py
@@ -2597,6 +2597,15 @@ def test_shutdown_clears_feature_flag_called_dedupe_cache(self):
                 "rediss://user:secret@cache.example.com:6380/1?ttl=120",
                 "rediss://user:secret@cache.example.com:6380/1",
             ),
+            ("redis://[::1]:6379/0?ttl=120", "redis://[::1]:6379/0"),
+            (
+                "rediss://[2001:db8::1]:6380/1?ttl=120",
+                "rediss://[2001:db8::1]:6380/1",
+            ),
+            (
+                "redis://user:p%40ss@[::1]:6379/0?ttl=120",
+                "redis://user:p%40ss@[::1]:6379/0",
+            ),
         ]
     )
     def test_flag_fallback_cache_url_accepts_redis_schemes(

From c60e7a62d78689a38ad87bd31241b9678ef7d061 Mon Sep 17 00:00:00 2001
From: "releaser-posthog-python[bot]"
 <262414804+releaser-posthog-python[bot]@users.noreply.github.com>
Date: Wed, 11 Nov 2026 18:10:51 +0000
Subject: [PATCH 243/245] chore: Release v7.87.1 [skip ci]

---
 .sampo/changesets/gentle-harbor-ilmatar.md | 5 -----
 openfeature-provider/CHANGELOG.md          | 6 ++++++
 openfeature-provider/pyproject.toml        | 2 +-
 posthog/CHANGELOG.md                       | 6 ++++++
 posthog/version.py                         | 2 +-
 pyproject.toml                             | 2 +-
 uv.lock                                    | 4 ++--
 7 files changed, 17 insertions(+), 10 deletions(-)
 delete mode 100644 .sampo/changesets/gentle-harbor-ilmatar.md

diff --git a/.sampo/changesets/gentle-harbor-ilmatar.md b/.sampo/changesets/gentle-harbor-ilmatar.md
deleted file mode 100644
index 4c9ee83ec..000000000
--- a/.sampo/changesets/gentle-harbor-ilmatar.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-pypi/posthog: patch
----
-
-Fix `flag_fallback_cache_url` for Redis URLs with an IPv6 host: the brackets are kept, so the Redis flag cache is no longer disabled.
diff --git a/openfeature-provider/CHANGELOG.md b/openfeature-provider/CHANGELOG.md
index cd71a29c9..9bb007b32 100644
--- a/openfeature-provider/CHANGELOG.md
+++ b/openfeature-provider/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to `openfeature-provider-posthog` are documented here. This
 file is maintained by [Sampo](https://github.com/bruits/sampo) from changesets in
 `.sampo/changesets/` that target `pypi/openfeature-provider-posthog`.
 
+## 0.1.158 — 2026-11-11
+
+### Patch changes
+
+- Updated dependencies: posthog@7.87.1
+
 ## 0.1.157 — 2026-11-11
 
 ### Patch changes
diff --git a/openfeature-provider/pyproject.toml b/openfeature-provider/pyproject.toml
index c07e83989..120233a50 100644
--- a/openfeature-provider/pyproject.toml
+++ b/openfeature-provider/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openfeature-provider-posthog"
-version = "0.1.157"
+version = "0.1.158"
 description = "Official PostHog provider for the OpenFeature Python SDK."
 readme = "README.md"
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/posthog/CHANGELOG.md b/posthog/CHANGELOG.md
index 04902a954..c554996eb 100644
--- a/posthog/CHANGELOG.md
+++ b/posthog/CHANGELOG.md
@@ -1,5 +1,11 @@
 # posthog
 
+## 7.87.1 — 2026-11-11
+
+### Patch changes
+
+- [c28716c2](https://github.com/posthog/posthog-python/commit/c28716c20d75b4ca5dfe2aaedd4f14ff7086a769) Fix `flag_fallback_cache_url` for Redis URLs with an IPv6 host: the brackets are kept, so the Redis flag cache is no longer disabled. — Thanks @ioannisj!
+
 ## 7.87.0 — 2026-11-11
 
 ### Minor changes
diff --git a/posthog/version.py b/posthog/version.py
index 1a38d7357..b650937f8 100644
--- a/posthog/version.py
+++ b/posthog/version.py
@@ -1 +1 @@
-VERSION = "7.87.0"
+VERSION = "7.87.1"
diff --git a/pyproject.toml b/pyproject.toml
index 683d979bb..7889a1ad1 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "posthog"
-version = "7.87.0"
+version = "7.87.1"
 description = "Integrate PostHog into any python application."
 authors = [{ name = "PostHog", email = "engineering@posthog.com" }]
 maintainers = [{ name = "PostHog", email = "engineering@posthog.com" }]
diff --git a/uv.lock b/uv.lock
index 229869463..f06f09591 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2723,7 +2723,7 @@ wheels = [
 
 [[package]]
 name = "openfeature-provider-posthog"
-version = "0.1.157"
+version = "0.1.158"
 source = { editable = "openfeature-provider" }
 dependencies = [
     { name = "openfeature-sdk" },
@@ -3280,7 +3280,7 @@ wheels = [
 
 [[package]]
 name = "posthog"
-version = "7.87.0"
+version = "7.87.1"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },

From 268c613b9cc50f377f0db2b5a6035eb692a40b02 Mon Sep 17 00:00:00 2001
From: Eli Reisman <eli.r@posthog.com>
Date: Wed, 11 Nov 2026 13:04:25 -0800
Subject: [PATCH 244/245] docs: regenerate the 8.x and migration references
 from this branch

Run with --major 8, so the 7.x and latest pages stay as main generated
them. The 8.x page now documents 8.0 as merged here (emails, per-event
$lib, MCP and AI options, Celery context options); the migration page
matches docs/migration-7.x-to-8.0.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 references/posthog-python-8.md         | 186 ++++++++++++++++++++++---
 references/posthog-python-migration.md | 155 ++++++++++++++++-----
 2 files changed, 286 insertions(+), 55 deletions(-)

diff --git a/references/posthog-python-8.md b/references/posthog-python-8.md
index cdaf0c02e..8f9198f3a 100644
--- a/references/posthog-python-8.md
+++ b/references/posthog-python-8.md
@@ -125,7 +125,7 @@ In an asyncio app, use `AsyncPosthog` as an async context manager instead. See [
 ### `Client(...)`
 
 ```python
-Client(project_api_key: str, host=None, *, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, super_options=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2)
+Client(project_api_key: str, host=None, *, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, max_retries=3, sync_mode=False, timeout: float = 15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, historical_migration=False, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries=1, super_properties=None, super_options=None, enable_exception_autocapture=False, log_captured_exceptions=False, project_root=None, privacy_mode=False, before_send=None, flag_fallback_cache_url=None, enable_local_evaluation=True, flag_definition_cache_provider: Optional[FlagDefinitionCacheProvider] = None, capture_exception_code_variables=False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: list[str] | None = None, enable_exception_autocapture_rate_limiting=False, exception_autocapture_bucket_size=ExceptionCapture.DEFAULT_BUCKET_SIZE, exception_autocapture_refill_rate=ExceptionCapture.DEFAULT_REFILL_RATE, exception_autocapture_refill_interval_seconds=ExceptionCapture.DEFAULT_REFILL_INTERVAL_SECONDS, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, secret_key=None, metrics: Optional[dict] = None, enable_full_ai_capture=False, capture_trace_context=False, traces: Optional[dict] = None, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None)
 ```
 
 Initialize a new PostHog client instance.
@@ -158,8 +158,9 @@ Name | Type | Description | Default
 `app_host` | `Optional[str]` | Your PostHog app host, such as `https://posthog.example.com`. `emails` sends there. Needed only when `host` is not PostHog Cloud, for example a reverse proxy, which must not receive the secret key. | `None`
 `email_request_timeout_seconds` | `float` | Timeout in seconds for each email send request. Defaults to 15. | `15`
 `email_request_max_retries` | `int` | Number of retries for an email send after a network error, a rate limit, or an unavailable service. Defaults to 2. Set to 0 when a job runner already retries the send. | `2`
+`migrated_from` | `Optional[str]` | The email provider you moved from, such as `"resend"`. `emails` sends it with every request. | `None`
 `super_properties` |  | Properties for every captured event. They fill only keys the event leaves unset, before `before_send` runs. `$set`, `$set_once`, `$groups` and `$group_set` fill one level deep. An event's own properties and context tags override them, and `before_send` can change or remove them. | `None`
-`super_options` |  | Capture options for every captured event, such as `{"cookieless_mode": True}`. They fill only options the event leaves unset, before `before_send` runs. An event's own `options` and context options override them, and `before_send` can change them. They also win over an event's legacy property for the same key, such as `$cookieless_mode`, so pass per-event overrides of that key as `options`. | `None`
+`super_options` |  | Capture options for every captured event, such as `{"cookieless_mode": True}`. They fill only options the event leaves unset, before `before_send` runs. An event's own `options` and context options override them, and `before_send` can change them. | `None`
 `enable_exception_autocapture` |  | Automatically capture uncaught exceptions. | `False`
 `log_captured_exceptions` |  | Also log exceptions captured by error tracking. | `False`
 `project_root` |  | Root path used to determine in-app stack frames for captured exceptions. Defaults to the current working directory. | `None`
@@ -218,7 +219,7 @@ Name | Type | Description | Default
 `flags` |  | A FeatureFlagEvaluations snapshot from evaluate_flags(). The exact values from the snapshot are attached with no extra /flags request. | 
 `send_feature_flags` |  | Deprecated. Prefer flags=... from evaluate_flags(). When truthy, evaluates flags during capture and attaches them to the event. | 
 `disable_geoip` |  | Whether to disable GeoIP for this event. It wins over a `$geoip_disable` in context tags or `super_properties`. A `$geoip_disable` property in this call's `properties` wins over it. | 
-`options` |  | Capture options for this event, such as `{"process_person_profile": False}`. Sent as given, for PostHog to validate. They override context options and `super_options`, which fill in before `before_send` runs. An option set at any layer wins over its legacy `$` property, such as `$process_person_profile`, set at any layer. A `None` option counts as unset. | 
+`options` |  | Capture options for this event, such as `{"process_person_profile": False}`. Sent as given, for PostHog to validate. They override context options and `super_options`, which fill in before `before_send` runs. An option overrides its legacy `$` property, such as `$process_person_profile`. A `None` option counts as unset. | 
 
 **Examples:**
 
@@ -459,10 +460,10 @@ except Exception as e:
 emails: Emails
 ```
 
-Send transactional email from PostHog email templates, and read the
-status of each email sent with `get`.
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
 
-Needs `secret_key`, a project secret API key with the `hog_flow:write`
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
 scope. Sends go to `app_host`, or to the PostHog Cloud app host of
 `host`. `email_request_timeout_seconds` and `email_request_max_retries`
 configure each send. A disabled or shut-down client sends nothing. See
@@ -601,6 +602,9 @@ get_feature_flag_result(key: str, distinct_id: ID_TYPES, *, groups: Optional[Map
 Get a FeatureFlagResult object which contains the flag result and payload for a key by evaluating locally or remotely
 depending on whether local evaluation is enabled and the flag can be locally evaluated.
 This also captures the `$feature_flag_called` event unless `send_feature_flag_events` is `False`.
+When the flag was evaluated remotely and its config version 2 record is a complete experiment
+split (an experiment rule with a rule ID and a variant key), it also captures the
+`$experiment_exposure` event, once per distinct ID, groups, flag, rule and variant.
 
 **Examples:**
 
@@ -1698,7 +1702,7 @@ Name | Type | Description | Default
 `client` | `Optional[Client]` | Optional `Client` instance. When provided, all events and exceptions are captured through this client rather than the global `posthog` module. Don't skip this if using a custom flag definition cache provider, and pass the custom `Client` instance here initialized with the custom provider so fork safety for that provider is handled correctly. | `None`
 `capture_exceptions` | `bool` | Whether to capture task exceptions via `capture_exception` (default `True`). | `True`
 `capture_task_lifecycle_events` | `bool` | Whether to emit lifecycle events of the task such as "started", "success", "failure" etc. (default `True`). | `True`
-`propagate_context` | `bool` | Whether to propagate PostHog context (distinct ID, session ID, tags) from the producer to the worker via task headers (default `True`). | `True`
+`propagate_context` | `bool` | Whether to propagate PostHog context (distinct ID, session ID, tags, context options) from the producer to the worker via task headers (default `True`). | `True`
 `task_filter` | `Optional[Callable[[Optional[str], dict[str, Any]], bool]]` | Optional callback `(task_name, task_properties) -> bool` expected to return `False` if a given task should not be tracked. | `None`
 
 **Functions:**
@@ -1843,7 +1847,7 @@ Needs the `async` extra, `posthog[async]`.
 ### `AsyncClient(...)`
 
 ```python
-AsyncClient(project_api_key: str, host: Optional[str] = None, *, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, super_options: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, privacy_mode: bool = False, enable_full_ai_capture: bool = False, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2) -> None
+AsyncClient(project_api_key: str, host: Optional[str] = None, *, debug: bool = False, max_queue_size: int = 10000, send: bool = True, on_error=None, flush_at: int = 100, flush_interval: float = 5.0, max_retries: int = 3, timeout: float = 15, thread: int = 1, disabled: bool = False, disable_geoip: bool = True, is_server: bool = True, historical_migration: bool = False, super_properties: Optional[dict[str, Any]] = None, super_options: Optional[dict[str, Any]] = None, before_send=None, log_captured_exceptions: bool = False, project_root: Optional[str] = None, capture_exception_code_variables: bool = False, code_variables_mask_patterns=None, code_variables_ignore_patterns=None, code_variables_mask_url_credentials=None, code_variables_detect_secrets=None, in_app_modules: Optional[list[str]] = None, capture_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_compression: Optional[Union[CaptureCompression, str]] = None, capture_ai_max_queue_size: int = 1000, capture_ai_timeout: float = 30, capture_ai_max_event_bytes: int = AI_MAX_MSG_SIZE, privacy_mode: bool = False, enable_full_ai_capture: bool = False, capture_trace_context: bool = False, secret_key: Optional[str] = None, personal_api_key: Optional[str] = None, feature_flags_request_timeout_seconds: float = 3, feature_flags_request_max_retries: int = 1, app_host: Optional[str] = None, email_request_timeout_seconds: float = 15, email_request_max_retries: int = 2, migrated_from: Optional[str] = None) -> None
 ```
 
 ### `AsyncClient.capture`
@@ -1902,10 +1906,10 @@ unless the event, a context tag or `super_properties` sets either one.
 emails: AsyncEmails
 ```
 
-Send transactional email from PostHog email templates, and read the
-status of each email sent with `get`.
+Send transactional email from PostHog email templates or from content
+in your code, and read the status of each email sent with `get`.
 
-Needs `secret_key`, a project secret API key with the `hog_flow:write`
+Needs `secret_key`, a project secret API key with the `transactional_email:write`
 scope, and `posthog[async]`. Sends go to `app_host`, or to the PostHog
 Cloud app host of `host`. `email_request_timeout_seconds` and
 `email_request_max_retries` configure each send. A disabled or shut-down
@@ -3142,6 +3146,13 @@ To narrow the set of flags that get attached to a captured event, use the in-mem
 helpers `only` and `only_accessed`. To narrow the set of flags requested
 from the server in the first place, pass `flag_keys` to `Client.evaluate_flags`.
 
+Reading a flag sends `$feature_flag_called`, deduplicated as `is_enabled`
+describes. When the flag was evaluated remotely and its config version 2 record is
+a complete experiment split (an experiment rule with a rule ID and a variant key),
+the read also sends `$experiment_exposure`. The SDK sends one exposure per
+distinct ID, groups, flag, rule and variant. `send_feature_flag_events=False`
+suppresses both events.
+
 **Functions:**
 
 Name | Description
@@ -3876,12 +3887,12 @@ span.update_name(f"{request.method} {route.pattern}")
 ### `Emails`
 
 ```python
-Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None) -> None
+Emails(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None, migrated_from: Optional[str] = None) -> None
 ```
 
 Bases: `_EmailsBase`
 
-Sends transactional email from PostHog email templates.
+Sends transactional email from PostHog email templates or from content in your code.
 
 `host` is your PostHog app host. PostHog Cloud ingestion hosts map to the
 app host, so `us.i.posthog.com` sends to `us.posthog.com`. Any other
@@ -3891,7 +3902,8 @@ Each send retries network errors, rate limits and an unavailable service up
 to `max_retries` times, with the same idempotency key. Set
 `max_retries=0` when a job runner already retries the send. `timeout`
 is in seconds, per request. Pass `session` to send through your own
-`requests.Session`, for example a test double.
+`requests.Session`, for example a test double. `migrated_from`, such
+as `"resend"`, tells PostHog which provider your sends came from.
 
 **Functions:**
 
@@ -3899,7 +3911,7 @@ Name | Description
 ---- | -----------
 `close` | Close the HTTP connections this client opened. A `session` you passed in stays open.
 `get` | Read what happened to an email that `send` queued.
-`send` | Queue one email from a transactional email template.
+`send` | Queue one email, from a template in PostHog or from content in your code.
 
 **Attributes:**
 
@@ -3908,6 +3920,7 @@ Name | Type | Description
 `disabled` |  | 
 `host` |  | 
 `max_retries` |  | 
+`migrated_from` |  | 
 `secret_key` |  | 
 `timeout` |  | 
 
@@ -3973,6 +3986,12 @@ host = determine_app_host(host)
 max_retries = max_retries
 ```
 
+#### `posthog.emails.Emails.migrated_from`
+
+```python
+migrated_from = migrated_from
+```
+
 #### `posthog.emails.Emails.secret_key`
 
 ```python
@@ -3982,21 +4001,26 @@ secret_key = secret_key.strip() if isinstance(secret_key, str) else None
 #### `posthog.emails.Emails.send`
 
 ```python
-send(*, to: str, template_id: Union[str, UUID], template_data: Optional[Mapping[str, Any]] = None, distinct_id: Optional[str] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendEmailResult
+send(**kwargs: Any) -> SendEmailResult
 ```
 
-Queue one email from a transactional email template.
+Queue one email, from a template in PostHog or from content in your code.
+
+Pass exactly one form. The template form names a template made in
+PostHog with `template_id`. The code form names the email with
+`template_key` and passes `subject` and `html`, `text` or both:
+see `CodeEmailArgs`.
 
 **Parameters:**
 
 Name | Type | Description | Default
 ---- | ---- | ----------- | -------
-`to` | `str` | One recipient email address. | *required*
-`template_id` | `Union[str, UUID]` | The UUID of a template made transactional in PostHog. | *required*
-`template_data` | `Optional[Mapping[str, Any]]` | Values for the template's `{{ variables.* }}` placeholders. Values are encoded the way capture encodes properties. | `None`
-`distinct_id` | `Optional[str]` | The recipient's distinct ID in your product. The email's events go to this person. Without it, they go to a person whose distinct ID is the email address. | `None`
-`idempotency_key` | `Optional[str]` | 1 to 255 visible ASCII characters. A send with a key that PostHog has already accepted queues nothing and returns the first send's result. Without it, the client makes a key that covers its own retries. Pass a key derived from what the email is for, such as `welcome:user_123`, to cover retries outside this call, too. | `None`
-`max_retries` | `Optional[int]` | Overrides the client's maximum number of retries for this send. `0` turns retries off. | `None`
+`to` |  | One recipient email address. | 
+`template_id` |  | The UUID of a template made transactional in PostHog. | 
+`template_data` |  | Values for the template's `{{ variables.* }}` placeholders. Values are encoded the way capture encodes properties. | 
+`distinct_id` |  | The recipient's distinct ID in your product. The email's events go to this person. Without it, they go to a person whose distinct ID is the email address. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. A send with a key that PostHog has already accepted queues nothing and returns the first send's result. Without it, the client makes a key that covers its own retries. Pass a key derived from what the email is for, such as `welcome:user_123`, to cover retries outside this call, too. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
 
 **Returns:**
 
@@ -4021,6 +4045,13 @@ emails.send(
     distinct_id="user_123",
     idempotency_key="welcome:user_123",
 )
+emails.send(
+    to="user@example.com",
+    template_key="password-reset",
+    subject="Reset your password",
+    html=rendered_html,
+    distinct_id="user_123",
+)
 ```
 
 #### `posthog.emails.Emails.timeout`
@@ -4208,3 +4239,112 @@ timestamp: NotRequired[Optional[Union[datetime, str]]]
 ```python
 uuid: NotRequired[Optional[Union[str, UUID]]]
 ```
+
+### `CodeEmailArgs`
+
+Bases: `_RecipientArgs`
+
+A send of email content that your code rendered for one recipient, named by a key.
+
+The content goes out as is. To send a React email, render it to HTML in
+your app first.
+
+An optional field passed as `None` counts as left out.
+
+**Parameters:**
+
+Name | Type | Description | Default
+---- | ---- | ----------- | -------
+`to` |  | One recipient email address. | 
+`template_key` |  | Names the email, so its metrics, logs and status group under it. Letters, digits, `-` and `_`, at most 400. | 
+`subject` |  | The subject line. | 
+`html` |  | The HTML body. Give `html`, `text` or both. | 
+`text` |  | The plain-text body. Without it, PostHog derives it from `html`. HTML with no text in it, such as a single image, goes out without a plain-text part. | 
+`from_` |  | A verified sender, such as `"Acme <hello@example.com>"`. | 
+`reply_to` |  | One address or a list of addresses. An empty list sends no reply-to. | 
+`capture_engagement` |  | Capture the email's opens and clicks as events of the recipient. Defaults to `True`. A project whose admin turned engagement capture off captures nothing, whatever the send asks. A template made in PostHog follows the project's setting, so the template form doesn't take it. | 
+`distinct_id` |  | The recipient's distinct ID in your product. | 
+`idempotency_key` |  | 1 to 255 visible ASCII characters. Template sends and code sends share one set of keys: a key already used for another email, or for a `template_id` send, raises `idempotency_key_reused`. A retry with the same key returns the first send's result, also when its workflow was paused since. | 
+`max_retries` |  | Overrides the client's maximum number of retries for this send. `0` turns retries off. | 
+
+**Attributes:**
+
+Name | Type | Description
+---- | ---- | -----------
+`capture_engagement` | `NotRequired[Optional[bool]]` | 
+`distinct_id` | `NotRequired[Optional[str]]` | 
+`from_` | `NotRequired[Optional[str]]` | 
+`html` | `NotRequired[Optional[str]]` | 
+`idempotency_key` | `NotRequired[Optional[str]]` | 
+`max_retries` | `NotRequired[Optional[int]]` | 
+`reply_to` | `NotRequired[Optional[Union[str, Sequence[str]]]]` | 
+`subject` | `str` | 
+`template_key` | `str` | 
+`text` | `NotRequired[Optional[str]]` | 
+`to` | `str` | 
+
+#### `posthog.emails.CodeEmailArgs.capture_engagement`
+
+```python
+capture_engagement: NotRequired[Optional[bool]]
+```
+
+#### `posthog.emails.CodeEmailArgs.distinct_id`
+
+```python
+distinct_id: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.from_`
+
+```python
+from_: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.html`
+
+```python
+html: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.idempotency_key`
+
+```python
+idempotency_key: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.max_retries`
+
+```python
+max_retries: NotRequired[Optional[int]]
+```
+
+#### `posthog.emails.CodeEmailArgs.reply_to`
+
+```python
+reply_to: NotRequired[Optional[Union[str, Sequence[str]]]]
+```
+
+#### `posthog.emails.CodeEmailArgs.subject`
+
+```python
+subject: str
+```
+
+#### `posthog.emails.CodeEmailArgs.template_key`
+
+```python
+template_key: str
+```
+
+#### `posthog.emails.CodeEmailArgs.text`
+
+```python
+text: NotRequired[Optional[str]]
+```
+
+#### `posthog.emails.CodeEmailArgs.to`
+
+```python
+to: str
+```
diff --git a/references/posthog-python-migration.md b/references/posthog-python-migration.md
index 1c6c18564..628909bc8 100644
--- a/references/posthog-python-migration.md
+++ b/references/posthog-python-migration.md
@@ -24,27 +24,30 @@ You need to change code if your app does any of these:
 - sends events to a self-hosted PostHog that does not serve the capture v1 endpoints
 - sends events through a proxy that redirects capture requests to another host
 - reuses one event `uuid` for more than one event
-- sets `$process_person_profile` to turn person processing on for events without a distinct ID
-- passes strings such as `"true"` for `$cookieless_mode`, `$ignore_sent_at` or `$process_person_profile`
 - expects `super_properties` to override properties passed to a single call, including `$set` and `$groups`
 - sets `$is_server`, `$geoip_disable` or a system property such as `$os` and expects the SDK's value to win
+- has a `before_send` hook that returns a new dict: copy `options`, or the event is sent without them, including the `process_person_profile=False` the SDK sets for events without a distinct ID (see [Event options](#event-options)). The same applies to MCP's `before_send` (see [MCP analytics](#mcp-analytics))
+- captures `$ai_` events with `capture()`: send them with `capture_ai()`
 - tests the AI integrations with a mock client and asserts on `capture`
 - passes its own client object to the AI integrations
-- sets `$lib` or `$lib_version`, or filters on `$lib = "posthog-python-mcp"`
+- sets `$lib` or `$lib_version` in a call's `properties`, a context tag or `super_properties`
+- filters insights or dashboards on `$lib = posthog-python-mcp`
 - passes a personal API key (`phx_...`) as the project API key
 - reads event content from the SDK's debug log
 - calls `alias()` without a `distinct_id` and relies on the context distinct ID
+- turns person processing off with `super_options`, `super_properties`, a context option or a context tag, and calls `alias`, `group_identify`, `set` or `set_once` (see [Identity and request context](#identity-and-request-context))
 - runs the Django, Flask or ASGI integration on 7.68 to 7.70 without tracing headers turned on (they are now read by default)
 
 ## Endpoints
 
 | Method | Endpoint |
 | --- | --- |
-| `capture`, `set`, `set_once`, `alias`, `group_identify`, `capture_exception` | `/i/v1/analytics/events` |
+| `capture`, `set`, `set_once`, `alias`, `group_identify`, `capture_exception`, `AsyncPosthog.capture_immediate` | `/i/v1/analytics/events` |
 | `capture_ai`, `capture_ai_immediate`, and the AI wrapper integrations | `/i/v1/ai/events` |
 | OpenTelemetry (`posthog.ai.otel`) | `/i/v0/ai/otel`, unchanged |
 
-If you send events to a self-hosted PostHog, check that it serves both endpoints before you upgrade.
+If you send events to a self-hosted PostHog, check that it serves both `/i/v1/analytics/events` and `/i/v1/ai/events` before you upgrade.
+Self-hosted PostHog serves the AI endpoint from a separate capture service, so check each route.
 An endpoint that is not served drops every event sent to it.
 
 If you send events through your own reverse proxy, update it before you upgrade:
@@ -62,15 +65,32 @@ If a proxy redirects capture requests to another host, point `host` at the final
 
 ## SDK identity
 
-PostHog sets `$lib` and `$lib_version` on every event from the `PostHog-Sdk-Info` request header, which is always `posthog-python/<version>`.
-The SDK removes `$lib` and `$lib_version` from the properties it sends.
-A value you set in a call, in `super_properties` or in `before_send` does not reach PostHog.
+By default every event carries `$lib: "posthog-python"` and the installed package version in `$lib_version`.
+PostHog stores the values the event is sent with.
 
-MCP instrumentation no longer relabels the client.
-In 7.x, `posthog.mcp.instrument()` and `PostHogMCP` set the client's identity to `posthog-python-mcp`.
-With the default client, or any client the app also used, every event and feature flag request from the app then reported `posthog-python-mcp`, not only the MCP events.
-In 8.0, MCP events report `posthog-python` like all other events.
-To find MCP traffic, filter on the `$mcp_*` events and properties instead of `$lib`.
+You can set them in a call's `properties`, a context tag or `super_properties`. Like any other property, each one comes from the most specific place that sets it, so set both in the same place.
+`$lib` and `$lib_version` count as set only when they are non-empty strings.
+If you set `$lib` without `$lib_version`, the SDK adds its own version only when `$lib` is `posthog-python`.
+A `$lib_version` without a `$lib` is replaced with the SDK's.
+`before_send` sees both and can change or remove them.
+In 7.x the SDK overwrote a `$lib` or `$lib_version` set in a call or a context tag.
+
+This changes `super_properties` too:
+
+- `super_properties={"$lib": "my-lib"}` sends no `$lib_version`. In 7.x it sent the SDK version.
+- `super_properties={"$lib_version": "1.0"}` without a `$lib` sends the SDK's `$lib` and version. In 7.x it sent `1.0`.
+
+If an event reaches PostHog without `$lib`, PostHog fills both from the SDK name and version your request sends.
+If `$lib` is that SDK name and `$lib_version` is missing, empty or not a string, PostHog fills `$lib_version` the same way.
+
+MCP analytics events from `posthog.mcp.instrument()` or `PostHogMCP` report `posthog-python-mcp` and the installed package version.
+The integration sets both in each event's own properties, so neither a context tag nor `super_properties` replaces them. `before_send` can.
+In 7.x the MCP integration relabeled the whole client, or the default client when `instrument()` got none: the app's own events, the request headers and feature flag requests.
+In 8.0 those report `posthog-python`, so one client can serve both.
+
+Custom events from `PostHogMCP.capture()` now report `posthog-python`. In 7.x they reported `posthog-python-mcp`.
+Custom events from `McpAnalytics.capture()`, the handle `instrument()` returns, still report `posthog-python-mcp`.
+If an insight or dashboard filters on `$lib = posthog-python-mcp`, check that it still finds the events you expect.
 
 ## Removed options and APIs
 
@@ -160,7 +180,13 @@ The SDK moves them out of `properties` for you.
 - `group_identify` no longer adds the context session ID. A session takes the person of its latest event, and this event's distinct ID is not the session's user.
 - `alias()` needs an explicit `distinct_id`. It no longer falls back to the context distinct ID, which can come from a request header the client controls. Without one, the call is dropped with a warning.
 - Context tags and context options now apply to `alias` and `group_identify`, below the call's own values, as they do for `capture`.
-- Person processing turned off in the context, with `set_context_option("process_person_profile", False)` or a `$process_person_profile` tag, or in `super_options`, now applies to `$create_alias` and `$groupidentify` events too. A `$process_person_profile: False` in `super_properties` already did this in 7.x. PostHog drops these events when person processing is off, with an ingestion warning. Capture accepts them, so `on_error` does not report the drop. To keep them, turn person processing off per call instead.
+- `process_person_profile: False` from a context option, `super_options` or a `$process_person_profile` entry in `super_properties` reaches `alias`, `group_identify`, `set` and `set_once` too. A `$process_person_profile` context tag reaches only `alias` and `group_identify`, because `set` and `set_once` add context tags to the person properties they set. Context tags and options are new on `alias` and `group_identify`; `super_properties` already reached them in 7.x. PostHog drops the `$create_alias` and `$groupidentify` events when person processing is off, with an ingestion warning, so they never merge a person or update a group. It keeps the event from `set` or `set_once` but ignores its person update. Once the person exists, events sent with `process_person_profile: False` are still linked to it and billed as identified events. Capture accepts these events, so `on_error` does not report the drop. To keep them, pass the option on the call, which wins over context and `super_options`, or set it in `before_send`:
+
+  ```python
+  posthog.alias(previous_id="anon-1", distinct_id="user-1", options={"process_person_profile": True})
+  posthog.group_identify("company", "acme", {"name": "Acme"}, options={"process_person_profile": True})
+  posthog.set(distinct_id="user-1", properties={"plan": "pro"}, options={"process_person_profile": True})
+  ```
 
 ## Tracing headers
 
@@ -188,21 +214,29 @@ Capture v1 sends processing options in an `options` object, next to `properties`
   posthog.capture("signed_up", distinct_id="user-1", options={"cookieless_mode": True})
   ```
 
+  The MCP capture methods take `event_options` instead (see [MCP analytics](#mcp-analytics)), and the AI integrations take `posthog_options` (see [AI capture](#ai-capture)).
+
 - `super_options`, a new `Client`, `AsyncPosthog` and module setting, sets options on every event, like `super_properties`.
 - `set_context_option(key, value)` sets an option for the current context, like `tag()`. `get_context_options()` returns the options of the current context. Both exist on `Client` and as module functions. `AsyncPosthog` has no context methods, like it has no `tag()`, so call the module functions. They apply to every client in the context.
+- The Celery integration propagates context options to workers, like tags.
+  - A propagated `process_person_profile: True` turns person processing on for worker events without a distinct ID. Each of those events creates a person.
+  - In eager mode (`task_always_eager`), Celery publishes nothing, so the distinct ID, tags and options do not reach the task's events. To carry them, pass the task's PostHog headers with `task.apply(headers=...)`, as described in [references/middleware_configuration.md](../references/middleware_configuration.md).
 - Context tags and options reach `capture`, `capture_ai`, `capture_exception`, `alias` and `group_identify`. Context options also reach `set` and `set_once`. `super_properties` and `super_options` reach every method.
 - Options are sent as given. PostHog validates them. It drops an event with an option value it cannot read, such as a list for `cookieless_mode`, as `invalid_options`, and `on_error` reports it.
 - An `options` value that is not a dict is logged as an error and ignored. The event is still sent.
-- The legacy option properties, the `$`-prefixed properties legacy capture reads as settings, still work. They fill the matching option only when it is unset, and the SDK always removes them from `properties`. Their values are no longer converted, so pass `True` or `False`, not `"true"`.
+- Each option replaces a legacy option property:
 
-  | Legacy option property | Option |
+  | Option | Replaces |
   | --- | --- |
-  | `$cookieless_mode` | `cookieless_mode` |
-  | `$ignore_sent_at` | `disable_skew_correction` |
-  | `$product_tour_id` | `product_tour_id` |
-  | `$process_person_profile` | `process_person_profile` |
+  | `cookieless_mode` | `$cookieless_mode` |
+  | `disable_skew_correction` | `$ignore_sent_at` |
+  | `product_tour_id` | `$product_tour_id` |
+  | `process_person_profile` | `$process_person_profile` |
 
-- An option set at any layer wins over its legacy property set at any layer. For example, `super_options={"cookieless_mode": True}` wins over an event's `$cookieless_mode: False`. When you move a default to options, move the per-event overrides of that key to options too.
+  Legacy option properties still work, but an option overrides its legacy property. Use options.
+- Pass `True` or `False` for `cookieless_mode`, `disable_skew_correction` and `process_person_profile`. PostHog also reads common forms such as `"false"`, `"off"` or `0`.
+
+- These four options are the full set. PostHog ignores any other key in `options`. Session and window IDs stay `$session_id` and `$window_id` properties (see [Session and window IDs](#session-and-window-ids)).
 - A `None` option counts as unset, so a later step can fill it.
 
 Values apply in this order. Steps 2 to 4 fill only the options and properties that the steps before them left unset:
@@ -210,41 +244,62 @@ Values apply in this order. Steps 2 to 4 fill only the options and properties th
 1. the `options` and `properties` of the call, then the call's `disable_geoip` argument, which fills `$geoip_disable`
 2. context options and tags
 3. `super_options` and `super_properties`
-4. values the SDK sets: `$is_server` from `is_server`, `$geoip_disable` from the client's `disable_geoip` setting, system properties such as `$os` and `$python_version`, the `$feature/<key>` and `$active_feature_flags` properties from `flags` or `send_feature_flags`, `$trace_id` and `$span_id` from the active OpenTelemetry span (in `capture` and `capture_ai` only with `capture_trace_context=True`, and always in `capture_exception`), `options.process_person_profile = false` for events without a distinct ID, and `$release_id` from `POSTHOG_RELEASE_ID`
+4. values the SDK sets: `$lib` and `$lib_version` as a pair (see [SDK identity](#sdk-identity)), `$is_server` from `is_server`, `$geoip_disable` from the client's `disable_geoip` setting, system properties such as `$os` and `$python_version`, the `$feature/<key>` and `$active_feature_flags` properties from `flags` or `send_feature_flags`, `$trace_id` and `$span_id` from the active OpenTelemetry span (in `capture` and `capture_ai` only with `capture_trace_context=True`, and always in `capture_exception`), `options.process_person_profile = false` for events without a distinct ID, and `$release_id` from `POSTHOG_RELEASE_ID`
 5. `before_send`, which sees the result of steps 1 to 4 and can change or remove any of it
-6. legacy properties, which fill unset options and are then removed
 
 A property set to `None` counts as set, so no later step fills it.
+`$lib` and `$lib_version` are the exception: they count as set only when they are non-empty strings (see [SDK identity](#sdk-identity)).
 `$set`, `$set_once`, `$groups` and `$group_set` fill one level deep.
 When the call and a later step both set one of them to a dict, the later step adds only the keys the call left out.
 For example, `super_properties={"$set": {"plan": "free", "source": "web"}}` and a call with `properties={"$set": {"plan": "pro"}}` send `{"plan": "pro", "source": "web"}`.
 
 These changes follow from this order:
 
-- Properties passed to a call now override `super_properties`. `super_properties` can no longer change `$lib` or `$lib_version`.
-- A `$is_server`, `$geoip_disable` or system property such as `$os` that you set in a call or a context tag now wins over the SDK's value. In 7.x the SDK overwrote it. `super_properties` win over the SDK's value too, so `super_properties={"$geoip_disable": False}` turns GeoIP lookup on for events, even with `disable_geoip=True`.
+- Properties passed to a call now override `super_properties`.
+- A `$is_server`, `$geoip_disable`, `$lib`, `$lib_version` or system property such as `$os` that you set in a call or a context tag now wins over the SDK's value. In 7.x the SDK overwrote it. `super_properties` win over the SDK's value too, so `super_properties={"$geoip_disable": False}` turns GeoIP lookup on for events, even with `disable_geoip=True`.
 - Feature flag properties from `flags` or `send_feature_flags` still lose to the same key in the call's `properties`, a context tag or `super_properties`, as in 7.x.
 - A `$trace_id` or `$span_id` in a context tag or `super_properties` now replaces the active OpenTelemetry span's IDs. In 7.x the span's IDs beat context tags. Setting either key in the call's `properties`, a context tag or `super_properties` stops the SDK adding both. In 7.x the SDK still added the other key.
 - A `disable_geoip` argument to a call belongs to that event, so it wins over context tags and `super_properties`. A `$geoip_disable` in the call's own `properties` still wins over it. `disable_geoip=False` now sends `$geoip_disable: false`. In 7.x it sent no `$geoip_disable` property.
 - The `groups` argument merges into a `$groups` property of the call, and wins key by key. In 7.x it replaced the property. MCP events merge their identity's groups into a custom `$groups` property the same way.
 - A `$set`, `$set_once`, `$groups` or `$group_set` in `super_properties` no longer replaces the whole value of the call. The two merge, and the call wins key by key.
-- An event without a distinct ID gets `options.process_person_profile = false`. A `$process_person_profile: true` property no longer turns person processing back on. Set the option instead.
-- Review your `before_send` hooks for the new event shape. To change an option, edit `options`: a legacy property that `before_send` adds does not replace an option that is already set. A hook that returns a new dict must copy `options`, or the event is sent without them. That includes the `process_person_profile = false` the SDK sets for an event without a distinct ID, so PostHog would create a person for its generated ID.
-- When the server enables minimal `$feature_flag_called` events, those events now keep `$window_id` and the legacy option properties, so their options still apply.
+- An event without a distinct ID gets `options.process_person_profile = false`. To turn person processing on for it, set the `process_person_profile` option.
+- Review your `before_send` hooks for the new event shape. To change an option, edit `options`. A hook that returns a new dict must copy `options`, or the event is sent without them. That includes the `process_person_profile = false` the SDK sets for an event without a distinct ID, so PostHog would create a person for its generated ID.
+- When the server enables minimal `$feature_flag_called` events, those events now keep `$window_id`. Their options still apply, because the trim removes only properties.
 
 ## AI capture
 
 - `capture_ai` and the AI wrapper integrations send to `/i/v1/ai/events`. The AI endpoint accepts events up to 8 MiB.
-- Send `$ai_` events with `capture_ai`. `capture()` sends every event to `/i/v1/analytics/events`, including `$ai_` events, which PostHog accepts there for now.
+- Send `$ai_` events with `capture_ai`. `capture()` sends every event to `/i/v1/analytics/events`, including `$ai_` events. PostHog accepts them there for now, but this is temporary.
 - `capture_ai` sends any event name to the AI endpoint. PostHog drops an event whose name does not start with `$ai_` as `misrouted_event`, and `on_error` reports it. The SDK writes only a debug log.
 - The OpenTelemetry integration (`PostHogSpanProcessor`, `PostHogTraceExporter`) is unchanged: it still exports spans over OTLP to `/i/v0/ai/otel`.
 - `enable_full_ai_capture` now controls only content: string truncation and media redaction. It no longer chooses the endpoint. `_use_ai_lane` and `_enable_multimodal_capture` still work as aliases.
 - The AI integrations call your client's `capture_ai`, and never `capture`. A custom client object must implement `capture_ai` and accept its `options` keyword argument. If the client has no `capture_ai`, the wrapper, callback handler or tracing processor logs one error when you create it and captures no AI events; provider calls still work. Before, such a client got `capture` calls.
 - Tests that pass a `Mock` client to an AI integration must assert on `mock.capture_ai`, not `mock.capture`.
-- When an AI integration or MCP falls back to a trace, run or session ID, it turns person processing off with a per-event option. This is the only option the integrations pass. It wins over `super_options`, context options and a `$process_person_profile: true` property. `before_send` can still change it.
+- When an AI integration or MCP falls back to a trace, run or session ID, it turns person processing off with a per-event option. This is the only option the integrations set on their own. It wins over your `posthog_options`, `options`, `super_options` and context options. `before_send` can still change it.
 - An empty or whitespace-only distinct ID passed to an AI integration, such as `posthog_distinct_id=""`, counts as missing, so the integration falls back the same way and turns person processing off. In 7.x, an empty ID gave non-streaming wrapper calls a random personless ID. Streaming calls, embeddings and LangChain used the trace or run ID with person processing on. OpenAI Agents already treated an empty ID as missing. Every integration sent a whitespace-only ID as given, with person processing on.
-- The AI integrations have no `options` argument. To set options on their events, use `set_context_option`, `super_options`, or a legacy property such as `$cookieless_mode` in `posthog_properties`.
-- MCP's `PostHogCaptureEvent` has an `options` key.
+- The AI integrations take capture options:
+  - Every wrapper method that takes `posthog_properties` also takes `posthog_options`, for the events of that call. This covers OpenAI, Anthropic and Gemini, sync and async, and the Claude Agent SDK `query()` and `PostHogClaudeSDKClient`. The name keeps it apart from the Claude Agent SDK's own `options`.
+  - The Gemini clients take `posthog_options` as a default for every call. A call's `posthog_options` win key by key.
+  - LangChain's `CallbackHandler` and `PostHogMiddleware`, OpenAI Agents' `instrument()` and `PostHogTracingProcessor`, and the Claude Agent SDK's `instrument()` and `PostHogClaudeAgentProcessor` take `options=` for every event. LangChain also reads `posthog_options` from run metadata, like `posthog_properties`. Like properties, the handler's or processor's options win over a run's or a query's. The `$exception` event LangChain captures for a failed run gets the same options.
+  - These are the event's own options, so they win over context options and `super_options`, which still fill the keys they leave unset. `before_send` can still change them.
+  - A value that is not a dict is logged as a warning and ignored. The provider call still runs, and the provider never receives `posthog_options`.
+
+  ```python
+  from posthog.ai.langchain import CallbackHandler
+  from posthog.ai.openai import OpenAI
+
+  client = OpenAI(posthog_client=posthog_client)
+  client.chat.completions.create(
+      model="gpt-5-mini",
+      messages=[{"role": "user", "content": "Hello"}],
+      posthog_distinct_id="user-1",
+      posthog_options={"cookieless_mode": True},
+  )
+
+  handler = CallbackHandler(
+      posthog_client, distinct_id="user-1", options={"cookieless_mode": True}
+  )
+  ```
 - New `Client` and `AsyncPosthog` arguments for the AI lane:
   - `capture_ai_compression`: default none. `POSTHOG_CAPTURE_COMPRESSION` does not apply to it.
   - `capture_ai_max_queue_size`: default 1000
@@ -256,6 +311,42 @@ These changes follow from this order:
 - `AsyncPosthog` sends events with `requests` in a worker thread. It uses `httpx` only for feature flags and remote config.
 - `AsyncPosthog` accepts `privacy_mode` and `enable_full_ai_capture`, with the same meaning as on `Client`. An AI integration given an `AsyncPosthog` client used to always truncate and redact media.
 
+## MCP analytics
+
+MCP events take options like other events, through an `event_options` argument and an `event_options` callback.
+
+- The `PostHogMCP` capture methods (`capture_tool_call`, `capture_initialize`, `capture_tools_list`, `capture_missing_capability` and `capture_feedback`) and `McpAnalytics.capture`, on the handle `instrument()` returns, take an `event_options` argument. It sets options on that event. For a failed tool call, it also sets them on the `$exception` event.
+- `MCPAnalyticsOptions(event_options=...)` sets options on every event `instrument()` captures automatically, including `$exception` events. It does not apply to `McpAnalytics.capture`. Like `event_properties`, it is a function of `(request, extra)` that returns a dict or `None`, and it can be sync or async.
+- `PostHogMCP.capture()` is the core client's `capture`, so it takes `options`. The MCP capture methods take `event_options`.
+- The SDK passes these options as the event's own options, so they win over context options and `super_options`.
+- An event without an identity always sends `process_person_profile: False`, even when `event_options` sets it to `True`. Its distinct ID is the session ID, so person processing would create a person for each session. To process a person, identify the user with `identify` or pass `distinct_id`.
+- An `event_options` value that is not a dict is logged and ignored. The event is still sent.
+
+```python
+from posthog.mcp import MCPAnalyticsOptions, PostHogMCP, instrument
+
+instrument(
+    server,
+    posthog,
+    MCPAnalyticsOptions(event_options=lambda request, extra: {"cookieless_mode": True}),
+)
+
+mcp_client = PostHogMCP("phc_...")
+mcp_client.capture_tool_call(
+    "search_docs",
+    distinct_id="user-1",
+    event_options={"process_person_profile": False},
+)
+```
+
+`instrument()` captures `$mcp_tool_call` after the tool handler returns.
+A context you open inside the handler has ended by then, so options you set in it with `set_context_option` do not reach `$mcp_tool_call`.
+Events you capture inside that context still get them.
+To set options on `$mcp_tool_call`, use the `event_options` callback.
+
+MCP's `before_send` gets each event's `options` in an `options` key of `PostHogCaptureEvent`.
+A hook that returns a new dict must copy them, or the event is sent without the anonymous `process_person_profile: False`.
+
 ## Batching and size limits
 
 - An analytics event over 10 MiB is dropped and logged, because no capture request can carry it. 7.x dropped events over 900 KiB. Capture drops an event over its own per-event limit and reports it in `CaptureError.drops` as `event_too_big`.

From 80563b2fb1dc6dc874d36e30eb673202f7269d1e Mon Sep 17 00:00:00 2001
From: Eli Reisman <eli.r@posthog.com>
Date: Wed, 11 Nov 2026 13:44:07 -0800
Subject: [PATCH 245/245] test(benchmarks): run the paired benchmarks against
 capture v1

main's benchmark harness (#1134, #1135) drove 7.x's legacy sender: the
client passed gzip=False and capture_mode="v0", and the loopback server
answered /batch with {"status":1}. 8.0 removed both options and only
speaks capture v1, so every benchmark worker failed on this branch, and
would on main after 8.0 merges.

- workload.py and run.py: drop gzip, capture_mode and
  POSTHOG_CAPTURE_MODE; requests are uncompressed capture v1.
- server.py: receive /i/v1/analytics/events and answer with a result per
  event uuid, so the SDK reads each event as delivered. The delivery
  checks are unchanged.
- test_benchmarks.py posts its synthetic batch to the v1 path; README
  describes the v1 transport.

benchmarks/test_benchmarks.py: 28 tests pass (18 errored before).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 benchmarks/README.md          |  2 +-
 benchmarks/run.py             |  3 +--
 benchmarks/server.py          | 10 ++++++++--
 benchmarks/test_benchmarks.py |  6 +++++-
 benchmarks/workload.py        |  2 --
 5 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/benchmarks/README.md b/benchmarks/README.md
index d428c862e..dfa275058 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -71,7 +71,7 @@ Capture fixtures are preconstructed outside measurement: event `benchmark`, iden
 - `capture.drain.steady.*` and `capture.drain.burst.*` record `completion_boundary=completed_delivery`. Steady flushes every 100 captures; burst flushes once after all captures. Parameters record `drain_strategy` and `flush_every`. Both include `flush(timeout_seconds=None)` and reports the complete delivery path's process CPU and allocations, including requests/serialization. The external worker timeout bounds this wait. Verification does not flush again: unfinished measured work cannot be rescued outside the measurement. Server CPU and server allocations are excluded; elapsed time includes loopback transport.
 - Enqueue-only allocation metrics are explicitly unavailable and direct readers to the drain workload.
 
-Capture uses public options `gzip=False`, `capture_mode="v0"`, `max_queue_size=100001`, `flush_at=100000`, and one-hour flush/poll intervals. The native consumer and size-driven batching remain active: burst describes the caller flush schedule, not retained queue size or a guaranteed HTTP request count. These metrics describe their named paths rather than pretending Python and Node have identical asynchronous lifecycles.
+Capture sends uncompressed capture v1 requests and uses public options `max_queue_size=100001`, `flush_at=100000`, and one-hour flush/poll intervals. The native consumer and size-driven batching remain active: burst describes the caller flush schedule, not retained queue size or a guaranteed HTTP request count. These metrics describe their named paths rather than pretending Python and Node have identical asynchronous lifecycles.
 
 ## Measurement methods
 
diff --git a/benchmarks/run.py b/benchmarks/run.py
index f3eca2d4c..ae6f4e1be 100644
--- a/benchmarks/run.py
+++ b/benchmarks/run.py
@@ -75,7 +75,6 @@ def worker_env():
         PYTHONHASHSEED="0",
         PYTHONNOUSERSITE="1",
         PYTHONDONTWRITEBYTECODE="1",
-        POSTHOG_CAPTURE_MODE="v0",
     )
     return env
 
@@ -375,7 +374,7 @@ def main(args=None):
             "file_format": "ALL_ALLOCATIONS",
             "scope": "PYMALLOC_MALLOC/CALLOC/REALLOC requests; all worker threads",
         },
-        "transport": "loopback HTTP receiver in coordinator process; uncompressed v0",
+        "transport": "loopback HTTP receiver in coordinator process; uncompressed capture v1",
         "warmup": "two refreshes; otherwise min(operations, 32 for 1000 flags or 160); verified phase reset before measurement",
         "settling": "two gc.collect calls separated by sleep(0)",
         "memory_sampling": "operation checkpoints; lifetime high-water mark includes setup and warmup",
diff --git a/benchmarks/server.py b/benchmarks/server.py
index b119c2ff9..e5071531d 100644
--- a/benchmarks/server.py
+++ b/benchmarks/server.py
@@ -102,7 +102,7 @@ def do_POST(self):
                                 definitions(spec["flag_count"], generation)
                             ).encode()
                             self.reply(200, b"{}")
-                        elif path == "/batch":
+                        elif path == "/i/v1/analytics/events":
                             if batch_delay:
                                 time.sleep(batch_delay)
                             batch = body["batch"]
@@ -136,7 +136,13 @@ def do_POST(self):
                                         owner.seen[sequence] = 1
                                         owner.state["unique_sequences"] += 1
                                         owner.state["missing_sequences"] -= 1
-                            self.reply(200, b'{"status":1}')
+                            # Capture v1 reports a result per event uuid; anything
+                            # else is an unreadable response to the SDK.
+                            results = {
+                                str(event.get("uuid")): {"result": "ok"}
+                                for event in batch
+                            }
+                            self.reply(200, json.dumps({"results": results}).encode())
                         else:
                             self.unexpected(path)
                     except (ValueError, KeyError, TypeError, AttributeError):
diff --git a/benchmarks/test_benchmarks.py b/benchmarks/test_benchmarks.py
index af51f4115..f6073086a 100644
--- a/benchmarks/test_benchmarks.py
+++ b/benchmarks/test_benchmarks.py
@@ -373,7 +373,11 @@ def test_balanced_duplicate_loss_fails_and_delivery_order_is_not_required(self):
                         # Replace the final 16 events with the preceding 16: total and
                         # per-identity counts stay identical, but sequences do not.
                         events = events[:-16] + events[-32:-16]
-                    control(server.url, "/batch", {"batch": list(reversed(events))})
+                    control(
+                        server.url,
+                        "/i/v1/analytics/events",
+                        {"batch": list(reversed(events))},
+                    )
                     workload.captured = spec["operations"]
                     for event in workload.events:
                         workload.captured_by_user[event["distinct_id"]] += 1
diff --git a/benchmarks/workload.py b/benchmarks/workload.py
index 570cde328..c8411f41d 100644
--- a/benchmarks/workload.py
+++ b/benchmarks/workload.py
@@ -38,8 +38,6 @@ def __init__(self, spec, host, client_class=None):
             timeout=5,
             max_retries=0,
             feature_flags_request_max_retries=0,
-            gzip=False,
-            capture_mode="v0",
             thread=1,
             on_error=lambda error, _batch: self.errors.append(str(error)),
             **({"personal_api_key": "benchmark-local-only"} if self.flags else {}),